| #### OpenGL Programming Guide (Addison-Wesley Publishing Company)

# Glossary

accumulation buffer

  Memory (bitplanes) that is used to accumulate a series of images generated in the color buffer. Using the accumulation buffer may significantly improve the quality of the image, but also take correspondingly longer to render. The accumulation buffer is used for effects such as depth of field, motion blur, and full-scene antialiasing.

aliasing

  A rendering technique that assigns to pixels the color of the primitive being rendered, regardless of whether that primitive covers all or only a portion of the pixel's area. This results in jagged edges, or jaggies.

alpha

  A fourth color component. The alpha component is never displayed directly and is typically used to control color blending. By convention, OpenGL alpha corresponds to the notion of opacity rather than transparency, meaning that an alpha value of 1.0 implies complete opacity, and an alpha value of 0.0 complete transparency.

ambient

  Ambient light is nondirectional and distributed uniformly throughout space. Ambient light falling upon a surface approaches from all directions. The light is reflected from the object independent of surface location and orientation with equal intensity in all directions.

animation

  Generating repeated renderings of a scene, with smoothly changing viewpoint and/or object positions, quickly enough so that the illusion of motion is achieved. OpenGL animation is almost always done using double-buffering.

antialiasing

  A rendering technique that assigns pixel colors based on the fraction of the pixel's area that's covered by the primitive being rendered. Antialiased rendering reduces or eliminates the jaggies that result from aliased rendering.

application-specific clipping

  Clipping of primitives against planes in eye coordinates; the planes are specified by the application using glClipPlane().

attribute group

  A set of related state variables, which OpenGL can save or restore together at one time.

back faces

  See faces.

bit

  Binary digit. A state variable having only two possible values: 0 or 1. Binary numbers are constructions of one or more bits.

bitmap

  A rectangular array of bits. Also, the primitive rendered by the glBitmap() command, which uses its bitmap parameter as a mask.

bitplane

  A rectangular array of bits mapped one-to-one with pixels. The framebuffer is a stack of bitplanes.

blending

  Reduction of two color components to one component, usually as a linear interpolation between the two components.

buffer

  A group of bitplanes that store a single component (such as depth or green) or a single index (such as the color index or the stencil index). Sometimes the red, green, blue, and alpha buffers together are referred to as the color buffer, rather than the color buffers.

C

  God's programming language.

C++

  The object-oriented programming language of a pagan deity.

client

  The computer from which OpenGL commands are issued. The computer that issues OpenGL commands can be connected via a network to a different computer that executes the commands, or commands can be issued and executed on the same computer. See also server.

client memory

  The main memory (where program variables are stored) of the client computer.

clip coordinates

  The coordinate system that follows transformation by the projection matrix and precedes perspective division. View-volume clipping is done in clip coordinates, but application-specific clipping is not.

clipping

  Elimination of the portion of a geometric primitive that's outside the half-space defined by a clipping plane. Points are simply rejected if outside. The portion of a line or of a polygon that's outside the half-space is eliminated, and additional vertices are generated as necessary to complete the primitive within the clipping half-space. Geometric primitives and the current raster position (when specified) are always clipped against the six half-spaces defined by the left, right, bottom, top, near, and far planes of the view volume. Applications can specify optional application-specific clipping planes to be applied in eye coordinates.

color index

  A single value that represents a color by name, rather than by value. OpenGL color indices are treated as continuous values (for example, floating-point numbers), while operations such as interpolation and dithering are performed on them. Color indices stored in the framebuffer are always integer values, however. Floating-point indices are converted to integers by rounding to the nearest integer value.

color-index mode

  An OpenGL context is in color-index mode if its color buffers store color indices rather than red, green, blue, and alpha color components.

color map

  A table of index-to-RGB mappings that's accessed by the display hardware. Each color index is read from the color buffer, converted to an RGB triple by lookup in the color map, and sent to the monitor.

components

  Single, continuous (for example, floating-point) values that represent intensities or quantities. Usually, a component value of zero represents the minimum value or intensity, and a component value of one represents the maximum value or intensity, though other ranges are sometimes used. Because component values are interpreted in a normalized range, they are specified independent of actual resolution. For example, the RGB triple (1, 1, 1) is white, regardless of whether the color buffers store 4, 8, or 12 bits each.

  Out-of-range components are typically clamped to the normalized range, not truncated or otherwise interpreted. For example, the RGB triple (1.4, 1.5, 0.9) is clamped to (1.0, 1.0, 0.9) before it's used to update the color buffer. Red, green, blue, alpha, and depth are always treated as components, never as indices.

concave

  Not convex.

context

  A complete set of OpenGL state variables. Note that framebuffer contents are not part of OpenGL state, but that the configuration of the framebuffer is.

convex

  A polygon is convex if no straight line in the plane of the polygon intersects the polygon more than twice.

convex hull

  The smallest convex region enclosing a specified group of points. In two dimensions, the convex hull is found conceptually by stretching a rubber band around the points so that all of the points lie within the band.

coordinate system

  In n-dimensional space, a set of n linearly independent vectors anchored to a point (called the origin). A group of coordinates specifies a point in space (or a vector from the origin) by indicating how far to travel along each vector to reach the point (or tip of the vector).

culling

  The process of eliminating a front face or back face of a polygon so that it isn't drawn.

current matrix

  A matrix that transforms coordinates in one coordinate system to coordinates of another system. There are three current matrices in OpenGL: the modelview matrix transforms object coordinates (coordinates specified by the programmer) to eye coordinates; the perspective matrix transforms eye coordinates to clip coordinates; the texture matrix transforms specified or generated texture coordinates as described by the matrix. Each current matrix is the top element on a stack of matrices. Each of the three stacks can be manipulated with OpenGL matrix-manipulation commands.

current raster position

  A window coordinate position that specifies the placement of an image primitive when it's rasterized. The current raster position and other current raster parameters are updated when glRasterPos() is called.

decal

  A method of calculating color values during texture application, where the texture colors replace the fragment colors or, if alpha blending is enabled, the texture colors are blended with the fragment colors, using only the alpha value.

depth

  Generally refers to the z window coordinate.

depth buffer

  Memory that stores the depth value at every pixel. To perform hidden-surface removal, the depth buffer records the depth value of the object that lies closest to the observer at every pixel. The depth value of every new fragment uses the recorded value for depth comparison and must pass the comparison test before being rendered.

depth-cuing

  A rendering technique that assigns color based on distance from the viewpoint.

diffuse

  Diffuse lighting and reflection accounts for the directionality of a light source. The intensity of light striking a surface varies with the angle between the orientation of the object and the direction of the light source. A diffuse material scatters that light evenly in all directions.

directional light source

  See infinite light source.

display list

  A named list of OpenGL commands. Display lists are always stored on the server, so display lists can be used to reduce network traffic in client-server environments. The contents of a display list may be preprocessed and might therefore execute more efficiently than the same set of OpenGL commands executed in immediate mode. Such preprocessing is especially important for computing intensive commands such as NURBS or polygon tessellation.

dithering

  A technique for increasing the perceived range of colors in an image at the cost of spatial resolution. Adjacent pixels are assigned differing color values; when viewed from a distance, these colors seem to blend into a single intermediate color. The technique is similar to the halftoning used in black-and-white publications to achieve shades of gray.

double-buffering

  OpenGL contexts with both front and back color buffers are double-buffered. Smooth animation is accomplished by rendering into only the back buffer (which isn't displayed), then causing the front and back buffers to be swapped. See glutSwapBuffers() in Appendix D.

edge flag

  A Boolean value at a vertex which marks whether that vertex precedes a boundary edge. glEdgeFlag*() may be used to mark an edge as not on the boundary. When a polygon is drawn in GL_LINE mode, only boundary edges are drawn.

element

  A single component or index.

emission

  The color of an object which is self-illuminating or self-radiating. The intensity of an emissive material is not attributed to any external light source.

evaluated

  The OpenGL process of generating object-coordinate vertices and parameters from previously specified Bézier equations.

execute

  An OpenGL command is executed when it's called in immediate mode or when the display list that it's a part of is called.

eye coordinates

  The coordinate system that follows transformation by the modelview matrix and precedes transformation by the projection matrix. Lighting and application-specific clipping are done in eye coordinates.

faces

  The sides of a polygon. Each polygon has two faces: a front face and a back face. Only one face or the other is ever visible in the window. Whether the back or front face is visible is effectively determined after the polygon is projected onto the window. After this projection, if the polygon's edges are directed clockwise, one of the faces is visible; if directed counterclockwise, the other face is visible. Whether clockwise corresponds to front or back (and counterclockwise corresponds to back or front) is determined by the OpenGL programmer.

flat shading

  Refers to a primitive colored with a single, constant color across its extent, rather than smoothly interpolated colors across the primitive. See Gouraud shading.

fog

  A rendering technique that can be used to simulate atmospheric effects such as haze, fog, and smog by fading object colors to a background color based on distance from the viewer. Fog also aids in the perception of distance from the viewer, giving a depth cue.

fonts

  Groups of graphical character representations generally used to display strings of text. The characters may be roman letters, mathematical symbols, Asian ideograms, Egyptian hieroglyphics, and so on.

fragment

  Fragments are generated by the rasterization of primitives. Each fragment corresponds to a single pixel and includes color, depth, and sometimes texture-coordinate values.

framebuffer

  All the buffers of a given window or context. Sometimes includes all the pixel memory of the graphics hardware accelerator.

front faces

  See faces.

frustum

  The view volume warped by perspective division.

gamma correction

  A function applied to colors stored in the framebuffer to correct for the nonlinear response of the eye (and sometimes of the monitor) to linear changes in color-intensity values.

geometric model

  The object-coordinate vertices and parameters that describe an object. Note that OpenGL doesn't define a syntax for geometric models, but rather a syntax and semantics for the rendering of geometric models.

geometric object

  See geometric model.

geometric primitive

  A point, a line, or a polygon.

Gouraud shading

  Smooth interpolation of colors across a polygon or line segment. Colors are assigned at vertices and linearly interpolated across the primitive to produce a relatively smooth variation in color. Also called smooth shading.

group

  Each pixel of an image in client memory is represented by a group of one, two, three, or four elements. Thus, in the context of a client memory image, a group and a pixel are the same thing.

half-spaces

  A plane divides space into two half-spaces.

hidden-line removal

  A technique to determine which portions of a wireframe object should be visible. The lines that comprise the wireframe are considered to be edges of opaque surfaces, which may obscure other edges that are farther away from the viewer.

hidden-surface removal

  A technique to determine which portions of an opaque, shaded object should be visible and which portions should be obscured. A test of the depth coordinate, using the depth buffer for storage, is a common method of hidden-surface removal.

homogeneous coordinates

  A set of n+1 coordinates used to represent points in n-dimensional projective space. Points in projective space can be thought of as points in euclidean space together with some points at infinity. The coordinates are homogeneous because a scaling of each of the coordinates by the same nonzero constant doesn't alter the point to which the coordinates refer. Homogeneous coordinates are useful in the calculations of projective geometry, and thus in computer graphics, where scenes must be projected onto a window.

image

  A rectangular array of pixels, either in client memory or in the framebuffer.

image primitive

  A bitmap or an image.

immediate mode

  Execution of OpenGL commands when they're called, rather than from a display list. No immediate-mode bit exists; the mode in immediate mode refers to use of OpenGL, rather than to a specific bit of OpenGL state.

index

  A single value that's interpreted as an absolute value, rather than as a normalized value in a specified range (as is a component). Color indices are the names of colors, which are dereferenced by the display hardware using the color map. Indices are typically masked rather than clamped when out of range. For example, the index 0xf7 is masked to 0x7 when written to a 4-bit buffer (color or stencil). Color indices and stencil indices are always treated as indices, never as components.

indices

  Preferred plural of index. (The choice between the plural forms indices or indexes - as well as matrices or matrixes and vertices or vertexes - has engendered much debate between the authors and principal reviewers of this guide. The authors' compromise solution is to use the -ices form but to state clearly for the record that the use of indice [sic], matrice [sic], and vertice [sic] for the singular forms is an abomination.)

infinite light source

  A directional source of illumination. The radiating light from an infinite light source strikes all objects as parallel rays.

interpolation

  Calculation of values (such as color or depth) for interior pixels, given the values at the boundaries (such as at the vertices of a polygon or a line).

IRIS GL

  Silicon Graphics proprietary graphics library, developed from 1982 through 1992. OpenGL was designed with IRIS GL as a starting point.

IRIS Inventor

  See Open Inventor.

jaggies

  Artifacts of aliased rendering. The edges of primitives that are rendered with aliasing are jagged rather than smooth. A near-horizontal aliased line, for example, is rendered as a set of horizontal lines on adjacent pixel rows rather than as a smooth, continuous line.

jittering

  A pseudo-random displacement (shaking) of the objects in a scene, used in conjunction with the accumulation buffer to achieve special effects.

lighting

  The process of computing the color of a vertex based on current lights, material properties, and lighting-model modes.

line

  A straight region of finite width between two vertices. (Unlike mathematical lines, OpenGL lines have finite width and length.) Each segment of a strip of lines is itself a line.

local light source

  A source of illumination which has an exact position. The radiating light from a local light source emanates from that position. Other names for a local light source are point light source or positional light source. A spotlight is a special kind of local light source.

logical operation

  Boolean mathematical operations between the incoming fragment's RGBA color or color-index values and the RGBA color or color-index values already stored at the corresponding location in the framebuffer. Examples of logical operations include AND, OR, XOR, NAND, and INVERT.

luminance

  The perceived brightness of a surface. Often refers to a weighted average of red, green, and blue color values that gives the perceived brightness of the combination.

matrices

  Preferred plural of matrix. See indices.

matrix

  A two-dimensional array of values. OpenGL matrices are all 4 × 4, though when stored in client memory they're treated as 1 × 16 single-dimension arrays.

modelview matrix

  The 4 × 4 matrix that transforms points, lines, polygons, and raster positions from object coordinates to eye coordinates.

modulate

  A method of calculating color values during texture application, where the texture and the fragment colors are combined.

monitor

  The device that displays the image in the framebuffer.

motion blurring

  A technique that uses the accumulation buffer to simulate what appears on film when you take a picture of a moving object or when you move the camera while taking a picture of a stationary object. In animations without motion blur, moving objects can appear jerky.

network

  A connection between two or more computers that allows each to transfer data to and from the others.

nonconvex

  A polygon is nonconvex if there exists a line in the plane of the polygon that intersects the polygon more than twice.

normal

  A three-component plane equation that defines the angular orientation, but not position, of a plane or surface.

normalized

  To normalize a normal vector, divide each of the components by the square root of the sum of their squares. Then, if the normal is thought of as a vector from the origin to the point (nx', ny', nz'), this vector has unit length.

  factor = sqrt(nx2 + ny2 + nz2)

  nx' = nx / factor

  ny' = ny / factor

  nz' = nz / factor

normal vectors

  See normal.

NURBS

  Non-Uniform Rational B-Spline. A common way to specify parametric curves and surfaces. (See GLU NURBS routines in Chapter 12.)

object

  An object-coordinate model that's rendered as a collection of primitives.

object coordinates

  Coordinate system prior to any OpenGL transformation.

Open Inventor

  An object-oriented 3D toolkit, built on top of OpenGL, based on a 3D scene database and user interaction components. It includes objects such as cubes, polygons, text, materials, cameras, lights, trackballs and handle boxes.

orthographic

  Nonperspective projection, as in some engineering drawings, with no foreshortening.

parameters

  Values passed as arguments to OpenGL commands. Sometimes parameters are passed by reference to an OpenGL command.

perspective division

  The division of x, y, and z by w, carried out in clip coordinates.

pixel

  Picture element. The bits at location (x, y) of all the bitplanes in the framebuffer constitute the single pixel (x, y). In an image in client memory, a pixel is one group of elements. In OpenGL window coordinates, each pixel corresponds to a 1.0 × 1.0 screen area. The coordinates of the lower-left corner of the pixel are x,y are (x, y), and of the upper-right corner are (x+1, y+1).

point

  An exact location in space, which is rendered as a finite-diameter dot.

point light source

  See local light source.

polygon

  A near-planar surface bounded by edges specified by vertices. Each triangle of a triangle mesh is a polygon, as is each quadrilateral of a quadrilateral mesh. The rectangle specified by glRect*() is also a polygon.

positional light source

  See local light source.

primitive

  A point, a line, a polygon, a bitmap, or an image. (Note: Not just a point, a line, or a polygon!)

projection matrix

  The 4 × 4 matrix that transforms points, lines, polygons, and raster positions from eye coordinates to clip coordinates.

proxy texture

  A placeholder for a texture image, which is used to determine if there are enough resources to support a texture image of a given size and internal format resolution.

quadrilateral

  A polygon with four edges.

rasterized

  Converted a projected point, line, or polygon, or the pixels of a bitmap or image, to fragments, each corresponding to a pixel in the framebuffer. Note that all primitives are rasterized, not just points, lines, and polygons.

rectangle

  A quadrilateral whose alternate edges are parallel to each other in object coordinates. Polygons specified with glRect*() are always rectangles; other quadrilaterals might be rectangles.

rendering

  Conversion of primitives specified in object coordinates to an image in the framebuffer. Rendering is the primary operation of OpenGL - it's what OpenGL does.

resident texture

  A texture image that is cached in special, high-performance texture memory. If an OpenGL implementation does not have special, high-performance texture memory, then all texture images are deemed resident textures.

RGBA

  Red, Green, Blue, Alpha.

RGBA mode

  An OpenGL context is in RGBA mode if its color buffers store red, green, blue, and alpha color components, rather than color indices.

server

  The computer on which OpenGL commands are executed. This might differ from the computer from which commands are issued. See client.

shading

  The process of interpolating color within the interior of a polygon, or between the vertices of a line, during rasterization.

shininess

  The exponent associated with specular reflection and lighting. Shininess controls the degree with which the specular highlight decays.

single-buffering

  OpenGL contexts that don't have back color buffers are single-buffered. You can use these contexts for animation, but take care to avoid visually disturbing flashes when rendering.

singular matrix

  A matrix that has no inverse. Geometrically, such a matrix represents a transformation that collapses points along at least one line to a single point.

specular

  Specular lighting and reflection incorporates reflection off shiny objects and the position of the viewer. Maximum specular reflectance occurs when the angle between the viewer and the direction of the reflected light is zero. A specular material scatters light with greatest intensity in the direction of the reflection, and its brightness decays, based upon the exponential value shininess.

spotlight

  A special type of local light source that has a direction (where it points to) as well as a position. A spotlight simulates a cone of light, which may have a fall-off in intensity, based upon distance from the center of the cone.

stencil buffer

  Memory (bitplanes) that is used for additional per-fragment testing, along with the depth buffer. The stencil test may be used for masking regions, capping solid geometry, and overlapping translucent polygons.

stereo

  Enhanced three-dimensional perception of a rendered image by computing separate images for each eye. Stereo requires special hardware, such as two synchronized monitors or special glasses to alternate viewed frames for each eye. Some implementations of OpenGL support stereo by having both left and right buffers for color data.

stipple

  A one- or two-dimensional binary pattern that defeats the generation of fragments where its value is zero. Line stipples are one-dimensional and are applied relative to the start of a line. Polygon stipples are two-dimensional and are applied with a fixed orientation to the window.

tessellation

  Reduction of a portion of an analytic surface to a mesh of polygons, or of a portion of an analytic curve to a sequence of lines.

texel

  A texture element. A texel is obtained from texture memory and represents the color of the texture to be applied to a corresponding fragment.

textures

  One- or two-dimensional images that are used to modify the color of fragments produced by rasterization.

texture mapping

  The process of applying an image (the texture) to a primitive. Texture mapping is often used to add realism to a scene. For example, you can apply a picture of a building facade to a polygon representing a wall.

texture matrix

  The 4 × 4 matrix that transforms texture coordinates from the coordinates in which they're specified to the coordinates that are used for interpolation and texture lookup.

texture object

  A named cache that stores texture data, such as the image array, associated mipmaps, and associated texture parameter values: width, height, border width, internal format, resolution of components, minification and magnification filters, wrapping modes, border color, and texture priority.

transformations

  The warping of spaces. In OpenGL, transformations are limited to projective transformations that include anything that can be represented by a 4 × 4 matrix. Such transformations include rotations, translations, (nonuniform) scalings along the coordinate axes, perspective transformations, and combinations of these.

triangle

  A polygon with three edges. Triangles are always convex.

vertex

  A point in three-dimensional space.

vertex array

  Where a block of vertex data (vertex coordinates, texture coordinates, surface normals, RGBA colors, color indices, and edge flags) may be stored in an array and then used to specify multiple geometric primitives through the execution of a single OpenGL command.

vertices

  Preferred plural of vertex. See indices.

viewpoint

  The origin of either the eye- or the clip-coordinate system, depending on context. (For example, when discussing lighting, the viewpoint is the origin of the eye-coordinate system. When discussing projection, the viewpoint is the origin of the clip-coordinate system.) With a typical projection matrix, the eye-coordinate and clip-coordinate origins are at the same location.

view volume

  The volume in clip coordinates whose coordinates satisfy the three conditions

  -w ≤ x ≤ w

  -w ≤ y ≤ w

  -w ≤ z ≤ w

  Geometric primitives that extend outside this volume are clipped.

VRML

  VRML stands for Virtual Reality Modeling Language, which is (according to the VRML Mission Statement) "a universal description language for multi-participant simulations." VRML is specifically designed to allow people to navigate through three-dimensional worlds thatare placed on the World Wide Web. The first versions of VRML are subsets of the Open Inventor file format with additions to allow hyperlinking to the Web (to URLs - Universal Resource Locators).

window

  A subregion of the framebuffer, usually rectangular, whose pixels all have the same buffer configuration. An OpenGL context renders to a single window at a time.

window-aligned

  When referring to line segments or polygon edges, implies that these are parallel to the window boundaries. (In OpenGL, the window is rectangular, with horizontal and vertical edges). When referring to a polygon pattern, implies that the pattern is fixed relative to the window origin.

window coordinates

  The coordinate system of a window. It's important to distinguish between the names of pixels, which are discrete, and the window-coordinate system, which is continuous. For example, the pixel at the lower-left corner of a window is pixel (0, 0); the window coordinates of the center of this pixel are (0.5, 0.5, z). Note that window coordinates include a depth, or z, component, and that this component is continuous as well.

wireframe

  A representation of an object that contains line segments only. Typically, the line segments indicate polygon edges.

working set

  On machines with special hardware that increases texture performance, this is the group of texture objects that are currently resident. The performance of textures within the working set outperforms the textures outside the working set.

X Window System

  A window system used by many of the machines on which OpenGL is implemented. GLX is the name of the OpenGL extension to the X Window System. (See Appendix C.)

# Index

accumulation buffer:
clearing: Clearing the Window
accumulation buffer: The Accumulation Buffer; Accumulation Buffer; Buffers and Their Uses
clearing: Clearing Buffers
depth-of-field effect, use for: Depth of Field
examples of use: The Accumulation Buffer
full range for best results, use: OpenGL Correctness Tips
motion blur, use for: Motion Blur
sample program with depth-of-field effect: Depth of Field
sample program with full-scene antialiasing: Scene Antialiasing
scene antialiasing, use for: Scene Antialiasing
AGL: AGL: OpenGL Extension to the Apple Macintosh
aglChoosePixelFmt(): Initialization, Initialization
aglCopyContext(): Managing an OpenGL Rendering Context, Controlling Rendering
aglCreateAGLPixmap(): Controlling Rendering, Off-screen Rendering
aglCreateContext(): Managing an OpenGL Rendering Context, Controlling Rendering
aglDestroyAGLPixmap(): Off-screen Rendering, Controlling Rendering
aglDestroyContext(): Managing an OpenGL Rendering Context, Controlling Rendering
aglGetConfig(): Initialization, Initialization
aglGetCurrentContext(): Controlling Rendering, Managing an OpenGL Rendering Context
aglGetCurrentDrawable(): Managing an OpenGL Rendering Context, Controlling Rendering
aglGetError(): Error Handling, Controlling Rendering
aglListPixelFmts(): Initialization, Initialization
aglMakeCurrent(): Managing an OpenGL Rendering Context, Controlling Rendering
aglQueryVersion(): Initialization, Initialization
aglSetOptions(): Controlling Rendering, On-screen Rendering
aglSwapBuffers(): Swapping Buffers, Controlling Rendering
aglUpdateCurrent(): Controlling Rendering, Updating the Rendering Buffers
aglUseFont(): Using an Apple Macintosh Font, Controlling Rendering
airbrushing: Alternative Uses for glDrawPixels() and glCopyPixels()
Akeley, Kurt: The Accumulation Buffer
aliasing, See antialiasing: Antialiasing
alpha: Blending
destination alpha: Antialiasing Polygons
material properties: Defining Material Properties
texture image data type: Texture Functions
alpha blending, See blending: Blending
alpha test: Alpha Test
querying current values: Alpha Test
rendering pipeline stage: Fragment Operations, Fragment Operations
ambient:
contribution to lighting equation: Ambient Term
global light: Global Ambient Light, Scaled Global Ambient Light
light: Real-World and OpenGL Lighting, Ambient, Diffuse, and Specular Light, Color
material properties: Material Colors, Diffuse and Ambient Reflection
animation: Animation; OpenGL Correctness Tips
antialiasing: Antialiasing
accumulation buffer used for: Scene Antialiasing
characters (by masking): Antialiased Characters
characters (by texturing): Texture-Mapping Applications
color-index mode: Antialiasing in Color-Index Mode
coverage values: Antialiasing
enabling for points or lines: Antialiasing Points or Lines
enabling for polygons: Antialiasing Polygons
lines: Antialiasing Points or Lines, Antialiasing
lines (by texturing): Texture-Mapping Applications
points: Drawing Round Points, Antialiasing Points or Lines
polygons: Antialiasing Polygons
RGBA mode: Antialiasing in RGBA Mode
sample program in color-index mode: Antialiasing in Color-Index Mode
sample program in RGBA mode: Antialiasing in RGBA Mode
sample program of filled polygons: Antialiasing Polygons
scene, with the accumulation buffer: Scene Antialiasing
architectural applications:
orthographic parallel projection, use of: Orthographic Projection
arcs: Quadrics: Rendering Spheres, Cylinders, and Disks
aspect ratio:
perspective projection: Perspective Projection
viewport transformation: Defining the Viewport
atmospheric effects, See fog: Fog
attribute groups: Attribute Groups
client: Attribute Groups
list of: OpenGL State Variables
performance tips: OpenGL Performance Tips
server: Attribute Groups
stack depth, obtaining: Attribute Groups
stacks: Attribute Groups
auxiliary buffers: Color Buffers; Selecting Color Buffers for Writing and Reading
Bézier:
basis: Evaluators, Prerequisites
curve: Defining and Evaluating a One-Dimensional Evaluator
sample program using mesh for surface: Defining Evenly Spaced Coordinate Values in Two Dimensions
sample program which draws curve: One-Dimensional Example: A Simple Bézier Curve
sample program which draws surface: Two-Dimensional Example: A Bézier Surface
surface: Two-Dimensional Evaluators
back-facing polygons: Reversing and Culling Polygon Faces
back-facing polygons:
culling: Reversing and Culling Polygon Faces
material property, specifying: Defining Material Properties
two-sided lighting: Two-sided Lighting
background: Clearing the Window
color: Clearing the Window
drawing a fixed: Masking Buffers, Drawing Depth-Buffered Images
background processing: Managing a Background Process
backward compatibility:
tessellation: Backward Compatibility
versions: Which Version Am I Using?
basis functions: Prerequisites; Evaluators
Bernstein:
basis: Prerequisites
polynomial: Defining and Evaluating a One-Dimensional Evaluator
billboarding: Alpha Test; Sample Uses of Blending
bitmaps: Drawing Pixels, Bitmaps, Fonts, and Images
display lists cache bitmap data: Display-List Design Philosophy
distorting: Cheap Image Transformation
drawing: Drawing the Bitmap
feedback mode: The Feedback Array
fonts, used for: Defining and Using a Complete Font, Bitmaps and Fonts
imaging pipeline operations: Imaging Pipeline
ordering of data in: Bitmaps and Fonts
origin of: Drawing the Bitmap
sample program: Bitmaps and Fonts
sample program that creates a font: Defining and Using a Complete Font
size of: Bitmaps and Fonts
bitplanes: RGBA versus Color-Index Mode
bitplanes: The Framebuffer
displayable colors, number of: RGBA Display Mode
blending: Blending; Blending
antialiasing polygons: Antialiasing Polygons
coverage calculations for antialiasing: Antialiasing
destination alpha: Antialiasing Polygons
enabling: The Source and Destination Factors
enabling for antialiasing: Antialiasing in RGBA Mode
factors (source and destination): The Source and Destination Factors
images: Interpolating Images
ordering polygons before drawing: A Blending Example
rendering pipeline stage: Fragment Operations, Fragment Operations
sample program for three-dimensional: Three-Dimensional Blending with the Depth Buffer
sample program with blended polygons: A Blending Example
texture function : Texture Functions
three dimensions, in: Three-Dimensional Blending with the Depth Buffer
uses of: Sample Uses of Blending
buffer, See framebuffer: Selecting Color Buffers for Writing and Reading
C programming language: OpenGL Command Syntax
CAD/CAM, See computer-aided design: Orthographic Projection
camera analogy: Overview: The Camera Analogy
environment mapping: Environment Mapping
viewport transformations: Viewport Transformation
capping, See computational solid geometry: Stencil Examples
characters:
antialiasing: Texture-Mapping Applications
circles: Quadrics: Rendering Spheres, Cylinders, and Disks
clearing the framebuffer: Clearing Buffers; Clearing the Window
affected by scissoring, dithering, and masking: Odds and Ends, Clearing Buffers
performance tips: OpenGL Performance Tips
client-server, See networked operation: Forcing Completion of Drawing
clip coordinates: Overview: The Camera Analogy; Additional Clipping Planes
feedback mode: The Feedback Array
clipping:
viewing volume: Perspective Projection
clipping: Viewing Volume Clipping
interference regions found using clipping planes: Finding Interference Regions
overview: Viewing
primitives in rendering pipeline: Primitive Assembly, Primitive Assembly
clipping planes:
additional clipping planes: Additional Clipping Planes, Overview: The Camera Analogy
depth-buffer resolution, effect on: OpenGL Correctness Tips
far: Troubleshooting Transformations, Perspective Projection
near: Troubleshooting Transformations, Perspective Projection
querying number of additional: Additional Clipping Planes
sample program with additional clipping planes: A Clipping Plane Code Example
color:
alpha values: Blending
background: Clearing the Window
cube showing blended RGB values: Computer Color
current raster color: Choosing a Color for the Bitmap
human perception: Color Perception
RGBA values for: Specifying a Color
RGBA values for: Computer Color
specifying: Specifying a Color
specifying for tessellation: Tessellation Callback Routines
specifying in color-index mode: Specifying a Color in Color-Index Mode
specifying in RGBA mode: Specifying a Color in RGBA Mode
color buffer: RGBA versus Color-Index Mode
color buffer: Buffers and Their Uses; Color Buffers; The Framebuffer; Computer Color
clearing: Clearing the Window
masking: Masking Buffers
color map: Color-Index Display Mode; Computer Color
loading for antialiasing: Antialiasing in Color-Index Mode
loading for smooth shading: Specifying a Shading Model
loading, using GLUT: Loading the Color Map
size of: Color-Index Display Mode
color-index mode:
choosing between RGBA mode and: Choosing between RGBA and Color-Index Mode
color-index mode: Color-Index Display Mode
changing between RGBA mode and: Changing between Display Modes
coverage calculations for antialiasing: Antialiasing
dithering: Dithering
layering with writemasks: Masking Buffers
lighting: Lighting in Color-Index Mode
lighting calculations in: The Mathematics of Color-Index Mode Lighting
texturing limitations: Specifying the Texture, Steps in Texture Mapping
vertex arrays, specifying values with: Step 2: Specifying Data for the Arrays
command syntax: OpenGL Command Syntax
compositing images: Sample Uses of Blending
compositing transformations: Examples of Composing Several Transformations
computational solid geometry: CSG Uses for Winding Rules
capping: Stencil Examples
difference of several contours: CSG Uses for Winding Rules
interference regions: Finding Interference Regions
intersection of two contours: CSG Uses for Winding Rules
union of several contours: CSG Uses for Winding Rules
Computer Graphics:
Principles and Practice: Homogeneous Coordinates and Transformation Matrices, RGBA versus Color-Index Mode, What You Should Know Before Reading This Guide
computer-aided design:
orthographic parallel projection, use of: Orthographic Projection
concave polygons:
GLU tessellation: Polygon Tessellation
stencil buffer, drawing with the: Drawing Filled, Concave Polygons Using the Stencil Buffer
cones: Quadrics: Rendering Spheres, Cylinders, and Disks; Initializing and Drawing Three-Dimensional Objects
improving rendering of: Dirichlet Domains
constant attenuation: Position and Attenuation
contours: Creating Contours
control points: One-Dimensional Example: A Simple Bézier Curve; A Simple NURBS Example; Two-Dimensional Evaluators; Evaluators and NURBS
convex polygons: Polygons
Conway, John: Life in the Stencil Buffer
coordinate systems:
local: Using glTranslate*() and glRotate*(), Grand, Fixed Coordinate System
coordinate systems:
grand, fixed: Building a Solar System, Using glTranslate*() and glRotate*(), Grand, Fixed Coordinate System
local: Building a Solar System, Building an Articulated Robot Arm
simple 2D: Coordinate System Survival Kit
coordinates:
See clip coordinates, depth coordinates, eye coordinates, homogeneous coordinates, normalized device coordinates, object coordinates, q texture coordinates, texture coordinates, w coordinates, or window coordinates: Grand, Fixed Coordinate System
coverage, pixel: Antialiasing
Coxeter, H. S. M.: Homogeneous Coordinates and Transformation Matrices
cross product: Using the gluLookAt() Utility Routine; Finding Normals for Analytic Surfaces
CSG, See computational solid geometry: CSG Uses for Winding Rules
culling: Reversing and Culling Polygon Faces
rendering pipeline stage: Primitive Assembly, Primitive Assembly
curves and curved surfaces: Curves and Curved Surfaces
aaa: Evaluators and NURBS
Curves and Surfaces for Computer-Aided Geometric Design: Prerequisites
cylinders: Quadrics: Rendering Spheres, Cylinders, and Disks
data types:
RGBA color conversion: Specifying a Color in RGBA Mode
special OpenGL: OpenGL Command Syntax
texture data: Specifying the Texture
warning about data type conversions: OpenGL Correctness Tips
decals: Making Decals; Alpha Test
polygon offset used for: Polygon Offset
texture function: Texture Functions
depth buffer:
clearing: Clearing the Window
depth buffer: Depth Buffer; A Hidden-Surface Removal Survival Kit; Buffers and Their Uses
aaa: A Hidden-Surface Removal Survival Kit
background, using masking for a common: Masking Buffers
blending, use for three-dimensional: Three-Dimensional Blending with the Depth Buffer
clearing: A Hidden-Surface Removal Survival Kit
clearing: Clearing Buffers
decals, for: Making Decals
Dirichlet domains, for: Dirichlet Domains
drawing static backgrounds: Drawing Depth-Buffered Images
masking: Masking Buffers
near frustum plane effect on resolution: OpenGL Correctness Tips
pixel data: Pixel-Transfer Operations, Copying Pixel Data within the Frame Buffer
depth coordinates: The Transformed Depth Coordinate; Overview: The Camera Analogy
perspective division: The Transformed Depth Coordinate
picking use: Picking and Depth Values
polygon offset: Polygon Offset
rendering pipeline stage for depth-range operations: Primitive Assembly, Primitive Assembly
sample program with picking: Picking and Depth Values
selection hit records: The Hit Record
depth test: Depth Test
aaa: Depth Test
rendering pipeline stage: Fragment Operations, Fragment Operations
depth-cuing, See fog: Fog
depth-of-field effect: Depth of Field
sample program: Depth of Field
destination factor, See blending: The Source and Destination Factors
diffuse:
contribution to lighting equation: Diffuse Term
light: Color, Ambient, Diffuse, and Specular Light
material properties: Diffuse and Ambient Reflection, Material Colors
directional light source: Position and Attenuation
Dirichlet domains: Dirichlet Domains
disks: Quadrics: Rendering Spheres, Cylinders, and Disks
display lists: State Management and Drawing Geometric Objects
nesting: Hierarchical Display Lists
display lists: An Example of Using a Display List
changing mode settings: Encapsulating Mode Changes
compiling: Naming and Creating a Display List
creating: Creating and Executing a Display List
deleting: Managing Display List Indices
disadvantages: Executing a Display List, Display-List Design Philosophy
error handling: OpenGL Correctness Tips, Creating and Executing a Display List
executing: Executing a Display List
executing: Creating and Executing a Display List
executing multiple: Executing Multiple Display Lists
font creation: Fonts and Display Lists, Executing Multiple Display Lists
hierarchical: Hierarchical Display Lists
immediate mode, mixing with: Executing a Display List
indices for, obtaining: Naming and Creating a Display List
naming: Naming and Creating a Display List
nesting limit, querying: Hierarchical Display Lists
networked operation: What's Stored in a Display List
performance tips: OpenGL Performance Tips
querying use of an index: Managing Display List Indices
rendering pipeline stage: Display Lists
sample program creating a font: Executing Multiple Display Lists
sample program for creating: An Example of Using a Display List, Creating and Executing a Display List
sharing among rendering contexts: Managing an OpenGL Rendering Context, Managing an OpenGL Rendering Context
state variables saved and restored: Managing State Variables with Display Lists
tessellation, use with: Tessellator Performance Tips
uses for: Display-List Design Philosophy, Encapsulating Mode Changes
vertex-array data: What's Stored in a Display List
what can be stored in: What's Stored in a Display List
distorted images: Cheap Image Transformation
texture images: Computing Appropriate Texture Coordinates
dithering: Dithering; OpenGL Correctness Tips; Dithering
and clearing: Clearing Buffers
rendering pipeline stage: Fragment Operations, Fragment Operations
dot product:
lighting calculations, use in: Spotlight Effect
double-buffering: Animation
automatic glFlush(): Forcing Completion of Drawing
changing between single-buffering and: Changing between Display Modes
object selection using the back buffer: Object Selection Using the Back Buffer
querying its presence: Color Buffers
sample program: Motion = Redraw + Swap
drawing:
forcing completion of: Forcing Completion of Drawing
points: OpenGL Geometric Drawing Primitives
polygons: OpenGL Geometric Drawing Primitives, Polygons as Points, Outlines, or Solids
rectangles: Rectangles
drawing:
clearing the window: Clearing the Window
icosahedron: An Example: Building an Icosahedron
preparing for: A Drawing Survival Kit
spheres, cylinders, and disks: Quadrics: Rendering Spheres, Cylinders, and Disks
drawing pixel data, See pixel data: Drawing Pixels, Bitmaps, Fonts, and Images
Duff, Tom: Sample Uses of Blending
edge flags: Marking Polygon Boundary Edges
tessellated polygons generate: Tessellation Callback Routines
vertex arrays, specifying values with: Step 2: Specifying Data for the Arrays
emission: Material Emission; Emission; Material Colors
enabling:
alpha test: Alpha Test
antialiasing of points or lines: Antialiasing Points or Lines
antialiasing polygons: Antialiasing Polygons
blending: The Source and Destination Factors
color material properties mode: Changing Material Properties
depth test: Depth Test
dithering: Dithering, Dithering
evaluators: One-Dimensional Example: A Simple Bézier Curve, Defining and Evaluating a Two-Dimensional Evaluator
fog: Using Fog
lighting: Enabling Lighting
line stippling: Stippled Lines
logical operations: Logical Operations
normal vectors for evaluated surfaces, automatic generation of: A Simple NURBS Example, Defining and Evaluating a Two-Dimensional Evaluator
polygon offset: Polygon Offset
polygon stippling: Stippling Polygons
stencil test: Stencil Test
texture coordinate generation: Creating Contours
texturing: Enable Texture Mapping, A Sample Program
unit length normal vectors ensured: Normal Vectors
endianness: Controlling Pixel-Storage Modes
environment mapping: Environment Mapping
error handling: Error Handling
error string description: Error Handling
recommended usage: OpenGL Correctness Tips
evaluators: Evaluators
basis functions: Prerequisites, Defining and Evaluating a One-Dimensional Evaluator
evenly spaced values: Defining Evenly Spaced Coordinate Values in One Dimension, Defining Evenly Spaced Coordinate Values in Two Dimensions
one-dimensional: One-Dimensional Evaluators
rendering pipeline stage: Evaluators
sample program using mesh for 2D Bézier surface: Defining Evenly Spaced Coordinate Values in Two Dimensions
sample program which draws 1D Bézier curve: One-Dimensional Example: A Simple Bézier Curve
sample program which draws 2D Bézier surface: Two-Dimensional Example: A Bézier Surface
sample program which generates texture coordinates: Using Evaluators for Textures
tessellation usage: OpenGL Performance Tips
texture coordinates, generating: Using Evaluators for Textures
two-dimensional: Two-Dimensional Example: A Bézier Surface, Two-Dimensional Evaluators
event management, using GLUT: Handling Input Events
example programs, See programs: Running the Program
extensions:
vendor-specific: Extensions to the Standard
eye coordinates: Additional Clipping Planes; Overview: The Camera Analogy
texture coordinate generation: Automatic Texture-Coordinate Generation, Creating Contours
fade effect: An Easy Fade Effect
Farin, Gerald E.: Prerequisites
feedback: Feedback
array contents: A Feedback Example
pass-through markers: Using Markers in Feedback Mode
querying current rendering mode: The Basic Steps
returned data: The Feedback Array
sample program: A Feedback Example
steps to perform: Feedback
tessellation, obtaining vertex data after: Tessellator Performance Tips
Feiner, Steven K.: What You Should Know Before Reading This Guide; Homogeneous Coordinates and Transformation Matrices
field of view: The Projection Transformation
field of view:
calculate, using trigonometry to: Troubleshooting Transformations
filtering: Filtering
mipmapped textures: Multiple Levels of Detail, Filtering
texture border colors: Repeating and Clamping Textures
flat shading: Specifying a Shading Model
flight simulation:
fog, use of: Fog
flushing: OpenGL Correctness Tips; Forcing Completion of Drawing
fog: Fog
blending factors: Fog Equations
color-index mode: Fog in Color-Index Mode
density: Fog Equations
enabling: Using Fog
equations: Fog Equations
hints: Using Fog
RGBA mode: Fog in RGBA Mode
sample program in color-index mode: Fog in Color-Index Mode
sample program in RGBA mode: Using Fog
Foley, James D.: What You Should Know Before Reading This Guide; RGBA versus Color-Index Mode; Homogeneous Coordinates and Transformation Matrices
fonts:
X fonts, using: Using an X Font
fonts: Fonts and Display Lists
antialiased characters (by masking): Antialiased Characters
antialiased characters (by texturing): Texture-Mapping Applications
bitmapped: Defining and Using a Complete Font
creating with display lists: Executing Multiple Display Lists
drawing: Drawing the Bitmap
drawing as bitmaps: Bitmaps and Fonts
multi-byte: Fonts and Display Lists
same program: Defining and Using a Complete Font
sample program using multiple display lists: Executing Multiple Display Lists
Foran, Jim: The q Coordinate
foreshortening, perspective: Perspective Projection
fragments: The Framebuffer
alpha test: Alpha Test
blending: Blending
depth test: Depth Test
rendering pipeline operations: Fragment Operations, Fragment Operations
scissor test: Scissor Test
tests: Testing and Operating on Fragments
texture functions: Texture Functions
framebuffer: The Framebuffer; RGBA versus Color-Index Mode
capacity per pixel: Buffers and Their Uses
clearing: Clearing Buffers
copying pixel data within: Imaging Pipeline, Copying Pixel Data within the Frame Buffer, Reading, Writing, and Copying Pixel Data
enabling for reading: Selecting Color Buffers for Writing and Reading
enabling for writing: Selecting Color Buffers for Writing and Reading
minimum configuration with the X Window System: Buffers and Their Uses
querying color resolution: RGBA versus Color-Index Mode
reading pixel data from: Reading, Writing, and Copying Pixel Data, Reading Pixel Data from Frame Buffer to Processor Memory
writing pixel data to: Writing Pixel Data from Processor Memory to Frame Buffer, Reading, Writing, and Copying Pixel Data
front-facing polygons: Reversing and Culling Polygon Faces
front-facing polygons:
specifying material property for: Defining Material Properties
two-sided lighting: Two-sided Lighting
frustum: Perspective Projection
ftp (file-transfer protocol) site:
GLUT source code: How to Obtain the Sample Code
GLX specification: GLX: OpenGL Extension for the X Window System
OpenGL Programming Guide: How to Obtain the Sample Code
Fundamentals of Computer Aided Geometric Design: Prerequisites
Fundamentals of Three-Dimensional Computer Graphics: Texture Mapping
Game of Life: Life in the Stencil Buffer
gamma correction: RGBA versus Color-Index Mode
Gardner, Martin: Life in the Stencil Buffer
geometric primitives: Describing Points, Lines, and Polygons; Overview
performance when specifying: OpenGL Performance Tips
rendering pipeline stage: Primitive Assembly
geosciences:
use of texturing in applications: Automatic Texture-Coordinate Generation
giraffe: Color-Index Display Mode
GLU:
tessellation: Polygon Tessellation
glAccum(): The Accumulation Buffer
glAlphaFunc(): Alpha Test
glAreTexturesResident(): A Working Set of Resident Textures
glArrayElement(): Dereference a Single Array Element
legal between glBegin() and glEnd(): Restrictions on Using glBegin() and glEnd()
Glassner, Andrew S. : What You Should Know Before Reading This Guide
glBegin(): OpenGL Geometric Drawing Primitives; OpenGL Geometric Drawing Primitives; Tessellation Callback Routines
restrictions: Restrictions on Using glBegin() and glEnd()
glBindTexture(): A Sample Program; Creating and Using Texture Objects
glBitmap(): Drawing the Bitmap; Bitmaps and Fonts
feedback mode: The Feedback Array
fonts, used for: Defining and Using a Complete Font
imaging pipeline operations: Imaging Pipeline
pixel-storage modes effect: Controlling Pixel-Storage Modes
glBlendFunc(): The Source and Destination Factors
glCallList(): Executing a Display List; Creating and Executing a Display List; An Example of Using a Display List
legal between glBegin() and glEnd(): Restrictions on Using glBegin() and glEnd()
glCallLists(): Executing Multiple Display Lists
fonts, use for: Fonts and Display Lists
legal between glBegin() and glEnd(): Restrictions on Using glBegin() and glEnd()
sample program: Defining and Using a Complete Font
glClear(): Clearing the Window; Odds and Ends; Clearing Buffers; Clearing the Window
depth buffer, clearing the: A Hidden-Surface Removal Survival Kit
glClearAccum(): Clearing the Window; Clearing Buffers
glClearColor(): Clearing the Window; Clearing the Window; Clearing Buffers
glClearDepth(): Clearing Buffers; Clearing the Window
glClearIndex(): Clearing the Window; Specifying a Color in Color-Index Mode; Clearing Buffers
fog, use with: Fog in Color-Index Mode
glClearStencil(): Clearing Buffers; Clearing the Window
glClipPlane(): Additional Clipping Planes
glColor*(): Specifying a Color ; Specifying a Color in RGBA Mode
legal between glBegin() and glEnd(): Restrictions on Using glBegin() and glEnd()
glColorMask(): Clearing Buffers; Masking Buffers
glColorMaterial(): Changing Material Properties
performance tips: OpenGL Performance Tips
glColorPointer(): Step 2: Specifying Data for the Arrays
glCopyPixels(): Copying Pixel Data within the Frame Buffer; Reading, Writing, and Copying Pixel Data
alternative uses: Alternative Uses for glDrawPixels() and glCopyPixels()
dithering, turn off: OpenGL Correctness Tips
feedback mode: The Feedback Array
glReadBuffer() effect: Selecting Color Buffers for Writing and Reading
imaging pipeline operations: Imaging Pipeline
pixel-transfer modes effect: Pixel-Transfer Operations
glCopyTexImage1D(): One-Dimensional Textures
glReadBuffer() effect: Selecting Color Buffers for Writing and Reading
pixel-transfer modes effect: Pixel-Transfer Operations
glCopyTexImage2D(): Specifying the Texture
glReadBuffer() effect: Selecting Color Buffers for Writing and Reading
pixel-transfer modes effect: Pixel-Transfer Operations
glCopyTexSubImage1D(): One-Dimensional Textures; One-Dimensional Textures
glReadBuffer() effect: Selecting Color Buffers for Writing and Reading
pixel-transfer modes effect: Pixel-Transfer Operations
glCopyTexSubImage2D(): Replacing All or Part of a Texture Image
glReadBuffer() effect: Selecting Color Buffers for Writing and Reading
pixel-transfer modes effect: Pixel-Transfer Operations
glCullFace(): Reversing and Culling Polygon Faces
glDeleteLists(): Fonts and Display Lists; Managing Display List Indices
glDeleteTextures(): Cleaning Up Texture Objects
glDepthFunc(): Depth Test
glDepthMask(): Masking Buffers
blending opaque and translucent objects: Three-Dimensional Blending with the Depth Buffer
glDepthRange(): The Transformed Depth Coordinate
gluUnProject(), relationship to: Reversing or Mimicking Transformations
glDisable(): Basic State Management; OpenGL as a State Machine
glDisableClientState(): Step 1: Enabling Arrays
glDrawArrays(): Dereference a Sequence of Array Elements
glDrawBuffer(): Writing Pixel Data from Processor Memory to Frame Buffer; Copying Pixel Data within the Frame Buffer; Selecting Color Buffers for Writing and Reading
glDrawElements(): Dereference a List of Array Elements
glDrawPixels(): Drawing Depth-Buffered Images; Writing Pixel Data from Processor Memory to Frame Buffer; Reading, Writing, and Copying Pixel Data; Stencil Examples
alternative uses: Alternative Uses for glDrawPixels() and glCopyPixels()
feedback mode: The Feedback Array
pixel-storage modes effect: Controlling Pixel-Storage Modes
pixel-transfer modes effect: Pixel-Transfer Operations
glEdgeFlag*(): Marking Polygon Boundary Edges
legal between glBegin() and glEnd(): Restrictions on Using glBegin() and glEnd()
glEdgeFlagPointer(): Step 2: Specifying Data for the Arrays
glEnable(): Basic State Management; Create, Position, and Enable One or More Light Sources
also see enabling: Reversing and Culling Polygon Faces
glEnableClientState(): Restrictions on Using glBegin() and glEnd(); Step 1: Enabling Arrays
glEnd(): Tessellation Callback Routines; OpenGL Geometric Drawing Primitives; OpenGL Geometric Drawing Primitives
restrictions: Restrictions on Using glBegin() and glEnd()
glEndList(): An Example of Using a Display List; Naming and Creating a Display List; Creating and Executing a Display List
glEvalCoord*(): Defining and Evaluating a One-Dimensional Evaluator ; Defining and Evaluating a Two-Dimensional Evaluator
legal between glBegin() and glEnd(): Restrictions on Using glBegin() and glEnd()
used instead of glVertex*(): One-Dimensional Example: A Simple Bézier Curve, Evaluators
glEvalMesh*(): Defining Evenly Spaced Coordinate Values in One Dimension; Defining Evenly Spaced Coordinate Values in Two Dimensions
glEvalPoint*():
legal between glBegin() and glEnd(): Restrictions on Using glBegin() and glEnd()
glFeedbackBuffer(): Feedback
glRenderMode(), use with: The Basic Steps
glFinish(): Forcing Completion of Drawing
glFlush(): Forcing Completion of Drawing; Forcing Completion of Drawing; OpenGL Correctness Tips
glFog*(): Fog Equations
glFrontFace(): Reversing and Culling Polygon Faces
glFrustum(): The Projection Transformation; Perspective Projection; Odds and Ends; Perspective Projection
glGenLists(): An Example of Using a Display List; Naming and Creating a Display List
fonts, use for: Fonts and Display Lists
glGenTextures(): Naming A Texture Object; A Sample Program
glGetBooleanv(): Basic State Management; OpenGL as a State Machine; OpenGL State Variables
double-buffering support, querying: Color Buffers
stereo support, querying: Color Buffers
glGetClipPlane(): The Query Commands
glGetDoublev(): Basic State Management; OpenGL as a State Machine; OpenGL State Variables
glGetError(): The Query Commands; Error Handling; OpenGL as a State Machine
glGetFloatv(): OpenGL as a State Machine; Basic State Management; OpenGL State Variables
line width attributes, obtaining: Wide Lines
point size attributes, obtaining: Point Details
glGetIntegerv(): OpenGL State Variables; Basic State Management; OpenGL as a State Machine
alpha test information, obtaining: Alpha Test
attribute stack depth, obtaining: Attribute Groups
clipping planes, obtaining number of additional: Additional Clipping Planes
color resolution, obtaining: RGBA versus Color-Index Mode
display list nesting limit, obtaining: Hierarchical Display Lists
matrix stack depth, obtaining: The Modelview Matrix Stack
maximum texture size, obtaining: Texture Proxy
name stack depth, obtaining: Creating the Name Stack
pixel map information, obtaining: Pixel Mapping
rendering mode, obtaining current: The Basic Steps
stencil-related values, obtaining: Stencil Queries
glGetLight*(): The Query Commands; OpenGL as a State Machine
glGetMap*(): The Query Commands
glGetMaterial*(): The Query Commands
glGetPixelMap*(): The Query Commands
glGetPointerv(): OpenGL State Variables; Basic State Management; OpenGL as a State Machine
glGetPolygonStipple(): OpenGL as a State Machine; The Query Commands
glGetString(): The Query Commands; Which Version Am I Using?
glGetTexEnv*(): The Query Commands
glGetTexGen*(): The Query Commands
glGetTexImage(): The Query Commands
pixel-storage modes effect: Controlling Pixel-Storage Modes
pixel-transfer modes effect: Pixel-Transfer Operations
glGetTexLevelParameter*(): Texture Proxy; The Query Commands
glGetTexParameter*(): The Query Commands
texture residency, obtaining: A Working Set of Resident Textures
glHint(): Antialiasing
fog use: Using Fog
texture use: A Sample Program
glIndex*(): Specifying a Color in Color-Index Mode
fog, use with: Fog in Color-Index Mode
legal between glBegin() and glEnd(): Restrictions on Using glBegin() and glEnd()
glIndexMask(): Clearing Buffers; Masking Buffers
glIndexPointer(): Step 2: Specifying Data for the Arrays
glInitNames(): Creating the Name Stack; Creating the Name Stack; The Basic Steps
glInterleavedArrays(): Interleaved Arrays
glIsEnabled(): OpenGL State Variables; Basic State Management; OpenGL as a State Machine
glIsList(): Managing Display List Indices
glIsTexture(): Naming A Texture Object
glLight*(): Creating Light Sources; Create, Position, and Enable One or More Light Sources; Creating Light Sources; Multiple Lights
glLightModel*(): Selecting a Lighting Model
glLineStipple(): Stippled Lines
glLineWidth(): Wide Lines
glListBase(): Executing Multiple Display Lists
fonts, use for: Fonts and Display Lists
sample program: Defining and Using a Complete Font
glLoadIdentity(): Odds and Ends; The Projection Transformation; General-Purpose Transformation Commands ; A Modeling Transformation Code Example
performance tips: OpenGL Performance Tips
viewing transformations, use before: The Viewing Transformation
glLoadMatrix*(): General-Purpose Transformation Commands ; General-Purpose Transformation Commands ; General-Purpose Transformation Commands ; Odds and Ends
glLoadName(): Creating the Name Stack; Creating the Name Stack
glLogicOp(): Logical Operations
glMap*(): Defining and Evaluating a Two-Dimensional Evaluator ; Defining and Evaluating a One-Dimensional Evaluator ; One-Dimensional Example: A Simple Bézier Curve
glMapGrid*(): Defining Evenly Spaced Coordinate Values in Two Dimensions; Defining Evenly Spaced Coordinate Values in One Dimension
glMaterial*(): Defining Material Properties; Define Material Properties for the Objects in the Scene
legal between glBegin() and glEnd(): Restrictions on Using glBegin() and glEnd()
performance tips: OpenGL Performance Tips
glMatrixMode(): The Projection Transformation; General-Purpose Transformation Commands
use with matrix stacks: Manipulating the Matrix Stacks
glMultMatrix*(): General-Purpose Transformation Commands ; Odds and Ends; General-Purpose Transformation Commands
performance tips: OpenGL Performance Tips
glNewList(): Creating and Executing a Display List; An Example of Using a Display List; Naming and Creating a Display List
glNormal*(): Normal Vectors
legal between glBegin() and glEnd(): Restrictions on Using glBegin() and glEnd()
glNormalPointer(): Step 2: Specifying Data for the Arrays
glOrtho(): Odds and Ends; Orthographic Projection
picking matrix use: Picking
glPassThrough(): Using Markers in Feedback Mode; Feedback
glPixelMap*(): Pixel Mapping
glPixelStore*(): Controlling Pixel-Storage Modes
cannot be stored in display lists: What's Stored in a Display List
polygon stippling: Stippling Polygons
texture image data, effect on: Replacing All or Part of a Texture Image, One-Dimensional Textures, Specifying the Texture, Replacing All or Part of a Texture Image, One-Dimensional Textures, Specifying the Texture
glPixelTransfer*(): Drawing Depth-Buffered Images; Pixel-Transfer Operations
texture image data, effect on: Specifying the Texture, One-Dimensional Textures, Replacing All or Part of a Texture Image, Replacing All or Part of a Texture Image, Specifying the Texture, One-Dimensional Textures
glPixelZoom(): Magnifying, Reducing, or Flipping an Image; Cheap Image Transformation
glPointSize(): Point Details
glPolygonMode(): Polygons as Points, Outlines, or Solids
antialiasing, effect on: Antialiasing Polygons
polygon offset, use with: Polygon Offset
glPolygonOffset(): Polygon Offset
glPolygonStipple(): Stippling Polygons
pixel-storage modes effect: Controlling Pixel-Storage Modes
glPopAttrib(): OpenGL as a State Machine; Managing State Variables with Display Lists; Attribute Groups; OpenGL State Variables
glPopClientAttrib(): OpenGL as a State Machine; Attribute Groups; OpenGL State Variables
glPopMatrix(): Manipulating the Matrix Stacks; Independently Moving the Light; Managing State Variables with Display Lists; Building an Articulated Robot Arm
restore orientation of coordinate systems: Building an Articulated Robot Arm
selection, use with: The Basic Steps
glPopName(): Creating the Name Stack; Creating the Name Stack
glPrioritizeTextures(): Texture Residence Strategies
glPushAttrib(): Attribute Groups; OpenGL as a State Machine; Managing State Variables with Display Lists; OpenGL State Variables
glPushClientAttrib(): Attribute Groups; OpenGL State Variables; OpenGL as a State Machine
glPushMatrix(): Managing State Variables with Display Lists; Manipulating the Matrix Stacks; Independently Moving the Light; Building an Articulated Robot Arm
save orientation of coordinate systems: Building an Articulated Robot Arm
selection, use with: The Basic Steps
glPushName(): Creating the Name Stack; The Basic Steps; Creating the Name Stack
glRasterPos*(): The Current Raster Position; Bitmaps and Fonts
images, for positioning: Reading, Writing, and Copying Pixel Data
selection hits, can cause: The Hit Record
glReadBuffer(): Selecting Color Buffers for Writing and Reading; Copying Pixel Data within the Frame Buffer; Writing Pixel Data from Processor Memory to Frame Buffer
glReadPixels(): Reading Pixel Data from Frame Buffer to Processor Memory; Reading, Writing, and Copying Pixel Data
glReadBuffer() effect: Selecting Color Buffers for Writing and Reading
pixel-storage modes effect: Controlling Pixel-Storage Modes
pixel-transfer modes effect: Pixel-Transfer Operations
glRect*(): Rectangles
glRenderMode(): The Basic Steps; The Hit Record; Feedback; The Basic Steps
glRotate*(): Building an Articulated Robot Arm
glRotate*(): Rotate; Odds and Ends; Building a Solar System
performance tips: OpenGL Performance Tips
glScale*(): Building an Articulated Robot Arm
glScale*(): The Modeling Transformation; Odds and Ends; Scale
performance tips: OpenGL Performance Tips
glScissor(): Scissor Test
glSelectBuffer(): The Basic Steps; The Basic Steps
display lists, cannot be stored in: What's Stored in a Display List
glShadeModel(): Specifying a Shading Model
glStencilFunc(): Stencil Test
glStencilMask(): Masking Buffers
glStencilOp(): Stencil Test
glTexCoord*(): A Sample Program; Assigning Texture Coordinates
legal between glBegin() and glEnd(): Restrictions on Using glBegin() and glEnd()
glTexCoordPointer(): Step 2: Specifying Data for the Arrays
glTexEnv*(): Texture Functions; A Sample Program
glTexGen*(): Automatic Texture-Coordinate Generation
environment mapping: Environment Mapping
glTexImage1D(): One-Dimensional Textures
pixel-storage modes effect: Controlling Pixel-Storage Modes
pixel-transfer modes effect: Pixel-Transfer Operations
glTexImage2D(): Specifying the Texture; A Sample Program
pixel-storage modes effect: Controlling Pixel-Storage Modes
pixel-transfer modes effect: Pixel-Transfer Operations
specifying mipmaps: Multiple Levels of Detail
glTexParameter*(): A Sample Program; Repeating and Clamping Textures
specifying filtering methods: Filtering
glTexSubImage1D(): One-Dimensional Textures
pixel-storage modes effect: Controlling Pixel-Storage Modes
pixel-transfer modes effect: Pixel-Transfer Operations
glTexSubImage2D(): Replacing All or Part of a Texture Image
pixel-storage modes effect: Controlling Pixel-Storage Modes
pixel-transfer modes effect: Pixel-Transfer Operations
glTranslate*(): Building a Solar System
glTranslate*(): Odds and Ends; Building an Articulated Robot Arm; Translate
performance tips: OpenGL Performance Tips
GLU: What Is OpenGL?; OpenGL-Related Libraries; Tessellators and Quadrics
drawing spheres, cylinders, and disks: Quadrics: Rendering Spheres, Cylinders, and Disks
error string description: Error Handling
obsolete routines:
gluBeginPolygon(): Backward Compatibility
gluEndPolygon(): Backward Compatibility
gluNextContour(): Backward Compatibility
quadrics: Quadrics: Rendering Spheres, Cylinders, and Disks
tessellation: Polygons
version numbers, obtaining: Utility Library Version
gluBeginCurve(): A Simple NURBS Example; Create a NURBS Curve or Surface
gluBeginSurface(): A Simple NURBS Example; Create a NURBS Curve or Surface
gluBeginTrim(): Trim a NURBS Surface
gluCylinder(): Quadrics: Rendering Spheres, Cylinders, and Disks; Quadrics Primitives
gluDeleteNurbsRenderer(): Manage a NURBS Object
gluDeleteQuadric(): Quadrics: Rendering Spheres, Cylinders, and Disks; Manage Quadrics Objects
gluDeleteTess(): Deleting a Tessellator Object; Backward Compatibility
gluDisk(): Quadrics Primitives; Quadrics: Rendering Spheres, Cylinders, and Disks
gluEndCurve(): A Simple NURBS Example; Create a NURBS Curve or Surface
gluEndSurface(): Create a NURBS Curve or Surface; A Simple NURBS Example
gluEndTrim(): Trim a NURBS Surface
gluErrorString(): Error Handling; Handle NURBS Errors; Manage Quadrics Objects
polygon tessellation: Tessellation Callback Routines
gluGetNurbsProperty(): The Query Commands; Control NURBS Rendering Properties
gluGetString(): Utility Library Version; The Query Commands
gluGetTessProperty(): The Query Commands; Other Tessellation Property Routines
gluLoadSamplingMatrices(): Control NURBS Rendering Properties
gluLookAt(): Building a Solar System
gluLookAt(): Using the gluLookAt() Utility Routine; The Viewing Transformation; A Simple Example: Drawing a Cube
gluNewNurbsRenderer(): Manage a NURBS Object; A Simple NURBS Example
gluNewQuadric(): Manage Quadrics Objects; Quadrics: Rendering Spheres, Cylinders, and Disks
gluNewTess(): Create a Tessellation Object; Backward Compatibility
gluNurbsCallback(): A Simple NURBS Example; Handle NURBS Errors
gluNurbsCurve(): Create a NURBS Curve or Surface; A Simple NURBS Example
gluNurbsProperty(): A Simple NURBS Example; Control NURBS Rendering Properties
gluNurbsSurface(): Create a NURBS Curve or Surface; A Simple NURBS Example
gluOrtho2D(): Orthographic Projection; OpenGL Correctness Tips
resized windows, use with: Coordinate System Survival Kit
gluPartialDisk(): Quadrics Primitives; Quadrics: Rendering Spheres, Cylinders, and Disks
gluPerspective(): Building a Solar System
gluPerspective(): Perspective Projection; The Projection Transformation
picking matrix use: Picking
gluPickMatrix(): Picking
gluProject(): Reversing or Mimicking Transformations
gluPwlCurve(): Trim a NURBS Surface
gluQuadricCallback(): Manage Quadrics Objects; Quadrics: Rendering Spheres, Cylinders, and Disks
gluQuadricDrawStyle(): Quadrics: Rendering Spheres, Cylinders, and Disks; Control Quadrics Attributes
gluQuadricNormals(): Control Quadrics Attributes; Quadrics: Rendering Spheres, Cylinders, and Disks
gluQuadricOrientation(): Control Quadrics Attributes; Quadrics: Rendering Spheres, Cylinders, and Disks
gluQuadricTexture(): Quadrics: Rendering Spheres, Cylinders, and Disks; Control Quadrics Attributes
gluScaleImage(): Specifying the Texture
gluSphere(): Quadrics: Rendering Spheres, Cylinders, and Disks; Quadrics Primitives
GLUT:
Basics of GLUT: The OpenGL Utility Toolkit; OpenGL-Related Libraries
basic functions: GLUT, the OpenGL Utility Toolkit
event management: Handling Input Events
glutCreateWindow(): Initializing and Creating a Window, Window Management
glutDisplayFunc(): Handling Window and Input Events, The Display Callback, The Display Callback
glutIdleFunc(): Managing a Background Process, Managing a Background Process
glutInit(): Initializing and Creating a Window, Window Management
glutInitDisplayMode(): Window Management, Initializing and Creating a Window
glutInitWindowPosition(): Window Management, Initializing and Creating a Window
glutInitWindowSize(): Window Management, Initializing and Creating a Window
glutKeyboardFunc(): Handling Input Events, Handling Window and Input Events
glutMainLoop(): Running the Program, Running the Program
glutMotionFunc(): Handling Window and Input Events, Handling Input Events
glutMouseFunc(): Handling Window and Input Events, Handling Input Events
glutPostRedisplay(): An Example of Using a Display List, Handling Window and Input Events, The Display Callback
glutReshapeFunc(): Handling Window and Input Events, Handling Input Events
simple example: Coordinate System Survival Kit
glutSetColor(): Loading the Color Map, Specifying a Color in Color-Index Mode, Window Management, Lighting in Color-Index Mode
smooth shading, use for: Specifying a Shading Model
glutSolidCone(): Initializing and Drawing Three-Dimensional Objects
glutSolidCube(): Initializing and Drawing Three-Dimensional Objects, Drawing Three-Dimensional Objects
glutSolidDodecahedron(): Initializing and Drawing Three-Dimensional Objects
glutSolidIcosahedron(): Initializing and Drawing Three-Dimensional Objects
glutSolidOctahedron(): Initializing and Drawing Three-Dimensional Objects
glutSolidSphere(): Drawing Three-Dimensional Objects, Initializing and Drawing Three-Dimensional Objects
glutSolidTeapot(): Initializing and Drawing Three-Dimensional Objects
glutSolidTetrahedron(): Initializing and Drawing Three-Dimensional Objects
glutSolidTorus(): Initializing and Drawing Three-Dimensional Objects
glutSwapBuffers(): Motion = Redraw + Swap
glutWireCone(): Initializing and Drawing Three-Dimensional Objects
glutWireCube(): Drawing Three-Dimensional Objects, Initializing and Drawing Three-Dimensional Objects
glutWireDodecahedron(): Initializing and Drawing Three-Dimensional Objects
glutWireIcosahedron(): Initializing and Drawing Three-Dimensional Objects
glutWireOctahedron(): Initializing and Drawing Three-Dimensional Objects
glutWireSphere(): Initializing and Drawing Three-Dimensional Objects, Drawing Three-Dimensional Objects, Building a Solar System
glutWireTeapot(): Initializing and Drawing Three-Dimensional Objects
glutWireTetrahedron(): Initializing and Drawing Three-Dimensional Objects
glutWireTorus(): Initializing and Drawing Three-Dimensional Objects
sample program introducing GLUT: Running the Program
window management: Window Management, Coordinate System Survival Kit
gluTessBeginContour(): Polygon Definition
gluTessBeginPolygon(): Polygon Definition
gluTessCallback(): Backward Compatibility; Tessellation Callback Routines; Polygon Definition
gluTessEndContour(): Polygon Definition
gluTessEndPolygon(): Polygon Definition
gluTessNormal(): Other Tessellation Property Routines; Tessellator Performance Tips; CSG Uses for Winding Rules
gluTessProperty(): Tessellation Properties; Polygon Definition
gluTessVertex(): Backward Compatibility; Polygon Definition
gluUnProject(): Reversing or Mimicking Transformations; Reversing or Mimicking Transformations
glVertex*(): Specifying Vertices
legal between glBegin() and glEnd(): Restrictions on Using glBegin() and glEnd()
using glEvalCoord*() instead: Evaluators
glVertexPointer(): Restrictions on Using glBegin() and glEnd(); Step 2: Specifying Data for the Arrays
glViewport(): The Viewport Transformation ; Defining the Viewport
using with resized windows: Coordinate System Survival Kit
GLX: GLX: OpenGL Extension for the X Window System; OpenGL-Related Libraries; OpenGL-Related Libraries
ftp site for GLX specification: GLX: OpenGL Extension for the X Window System
glXChooseVisual(): GLX Tips, Initialization, Initialization
glXCopyContext(): Controlling Rendering, Managing an OpenGL Rendering Context
glXCreateContext(): Managing an OpenGL Rendering Context, Controlling Rendering
glXCreateGLXPixmap(): Controlling Rendering, Off-Screen Rendering
glXDestroyContext(): Managing an OpenGL Rendering Context, Controlling Rendering
glXDestroyGLXPixmap(): Off-Screen Rendering, Controlling Rendering
glXGetClientString(): Initialization, Initialization
glXGetConfig(): Initialization, Buffers and Their Uses, Initialization
glXGetCurrentContext(): Controlling Rendering, Managing an OpenGL Rendering Context
glXGetCurrentDisplay(): Managing an OpenGL Rendering Context, Controlling Rendering
glXGetCurrentDrawable(): Controlling Rendering, Managing an OpenGL Rendering Context
glXIsDirect(): Managing an OpenGL Rendering Context, Controlling Rendering
glXMakeCurrent(): Controlling Rendering, Managing an OpenGL Rendering Context
glXQueryExtension(): Initialization, Initialization
glXQueryExtensionsString(): Initialization, Initialization
glXQueryServerString(): Initialization, Initialization
glXQueryVersion(): Initialization, Initialization
glXSwapBuffers(): Swapping Buffers, Motion = Redraw + Swap, Controlling Rendering
glXUseXFont(): Using an X Font, Controlling Rendering
glXWaitGL(): Controlling Rendering, Synchronizing Execution
performance tips: GLX Tips
glXWaitX(): Synchronizing Execution, Controlling Rendering
performance tips: GLX Tips
Gouraud shading, See smooth shading: Specifying a Shading Model
Haeberli, Paul: The q Coordinate; The Accumulation Buffer
haze, See fog: Fog
header file: Include Files
hidden-line removal: Hidden-Line Removal
polygon offset used for: Polygon Offset
hidden-surface removal: Depth Test; A Hidden-Surface Removal Survival Kit
hierarchical models: Manipulating the Matrix Stacks; Hierarchical Display Lists
picking: Picking with Multiple Names and a Hierarchical Model
highlights, See specular: Specular Reflection
hints: Antialiasing
fog: Using Fog
perspective correction: A Sample Program, Antialiasing , A Sample Program
hits (selection), See selection (hit records): The Hit Record
holes in polygons: Polygons; Drawing Filled, Concave Polygons Using the Stencil Buffer
homogeneous coordinates: Points; Homogeneous Coordinates
Hoschek, Josef: Prerequisites
Hughes, John F.: What You Should Know Before Reading This Guide; Homogeneous Coordinates and Transformation Matrices
IBM OS/2 Presentation Manager to OpenGL Interface, see PGL: OpenGL-Related Libraries
icosahedron, drawing: An Example: Building an Icosahedron
identity matrix: A Modeling Transformation Code Example; The Viewing Transformation; OpenGL Performance Tips; General-Purpose Transformation Commands
illumination, See lighting: Real-World and OpenGL Lighting
images: Drawing Pixels, Bitmaps, Fonts, and Images; Images
also see pixel data: Drawing Pixels, Bitmaps, Fonts, and Images
blending: Interpolating Images
compositing: Blending
distorted: Cheap Image Transformation
imaging pipeline: Reading, Writing, and Copying Pixel Data, Imaging Pipeline
interpolating between: Interpolating Images
magnifying or reducing: Magnifying, Reducing, or Flipping an Image
nonrectangular: Sample Uses of Blending
projecting: Texture-Mapping Applications
sample code which draws an image: Writing Pixel Data from Processor Memory to Frame Buffer
sample program which draws, copies, and zooms an image: Magnifying, Reducing, or Flipping an Image
scaling and rotating: Texture-Mapping Applications
sources of: Images
superimposing: Making Decals
transposing: Alternative Uses for glDrawPixels() and glCopyPixels(), Alternative Uses for glDrawPixels() and glCopyPixels()
warping: Texture-Mapping Applications
imaging pipeline, See images (imaging pipeline): Imaging Pipeline
immediate mode: State Management and Drawing Geometric Objects; Display Lists
display lists, mixing with: Executing a Display List
infinite light source: Position and Attenuation
input events:
handling, using GLUT: Handling Input Events
intensity:
texture image data type: Texture Functions
Interactive Inspection of Solids:
Cross-sections and Interferences: Finding Interference Regions
interference regions: Finding Interference Regions
interleaved arrays: Interleaved Arrays
interpolating:
color values and texture coordinates: Antialiasing , Assigning Texture Coordinates
invariance:
of an OpenGL implementation: OpenGL Invariance, OpenGL Correctness Tips
Inventor, see Open Inventor: OpenGL-Related Libraries
jaggies: Antialiasing
jittering: Scene Antialiasing; Scene Antialiasing; Jittering
accFrustum() routine: Scene Antialiasing
accPerspective() routine: Scene Antialiasing
sample code to jitter projection transformations: Scene Antialiasing
sample program with orthographic projection: Scene Antialiasing
Kilgard, Mark: How to Obtain the Sample Code; OpenGL-Related Libraries;
Basics of GLUT: The OpenGL Utility Toolkit; GLX: OpenGL Extension for the X Window System
Korobkin, Carl: The q Coordinate
Lasser, Dieter: Prerequisites
layers, drawing: Displaying Layers
Life, Game of: Life in the Stencil Buffer
light sources: Creating Light Sources
ambient light: Ambient, Diffuse, and Specular Light, Color
contribution to lighting equation: Contributions from Light Sources
diffuse light: Color, Ambient, Diffuse, and Specular Light
directional: Position and Attenuation
display lists cache values: Display-List Design Philosophy
infinite light source: Position and Attenuation
local light source: Position and Attenuation
maximum number of sources: Create, Position, and Enable One or More Light Sources
moving along with the viewpoint: Moving the Light Source Together with Your Viewpoint
moving light sources: Controlling a Light's Position and Direction
multiple light sources: Multiple Lights
performance tips: Create, Position, and Enable One or More Light Sources
positional: Position and Attenuation
rendering pipeline stage: Per-Vertex Operations, Per-Vertex Operations
RGBA values: RGB Values for Lights and Materials
sample program that moves the light source: Independently Moving the Light
specifying a light source: Create, Position, and Enable One or More Light Sources
specular light: Ambient, Diffuse, and Specular Light
spotlights: Spotlights
stationary: Keeping the Light Stationary
lighting:
enabling: Some Important Notes
lighting:also see light sources, material properties: Material Colors
ambient light: Real-World and OpenGL Lighting
approximation of the real world: Real-World and OpenGL Lighting
calculations in color-index mode: The Mathematics of Color-Index Mode Lighting
color-index mode: Lighting in Color-Index Mode
default values, using: Some Important Notes
display lists cache values: Display-List Design Philosophy
enabling: Create, Position, and Enable One or More Light Sources, Create, Position, and Enable One or More Light Sources
enabling and disabling: Enabling Lighting
equation that calculates lighting: The Mathematics of Lighting
global ambient light: Global Ambient Light, Scaled Global Ambient Light
lighting model: Selecting a Lighting Model
lighting model, specifying a: Select a Lighting Model
rendering pipeline stage: Per-Vertex Operations, Per-Vertex Operations
sample program introducing lighting: A Simple Example: Rendering a Lit Sphere
steps to perform: A Simple Example: Rendering a Lit Sphere
two-sided materials: Two-sided Lighting
viewer, local or infinite: Local or Infinite Viewpoint
line segment: Lines
linear attenuation: Position and Attenuation
lines: Lines
antialiasing: Texture-Mapping Applications, Antialiasing Points or Lines
connected closed loop, specifying: OpenGL Geometric Drawing Primitives, OpenGL Geometric Drawing Primitives
connected strip, specifying: OpenGL Geometric Drawing Primitives, OpenGL Geometric Drawing Primitives
feedback mode: The Feedback Array
querying line width: Wide Lines
sample program with wide, stippled lines: Stippled Lines
specifying: OpenGL Geometric Drawing Primitives, OpenGL Geometric Drawing Primitives
stippling: Stippled Lines
tessellated polygons decomposed into: Tessellation Callback Routines
width: Wide Lines
local light source: Position and Attenuation
logical operations:
rendering pipeline stage: Fragment Operations, Fragment Operations
transposing images, using for: Alternative Uses for glDrawPixels() and glCopyPixels()
lookup table, See color map: Color-Index Display Mode
luminance: Reading Pixel Data from Frame Buffer to Processor Memory; The Pixel Rectangle Reading Process
pixel data formats for: Reading Pixel Data from Frame Buffer to Processor Memory, Pixel Packing and Unpacking
texture image data type: Texture Functions
magnifying images: Magnifying, Reducing, or Flipping an Image
masking: Masking Buffers
antialiasing characters: Antialiased Characters
layers, drawing: Displaying Layers
rendering pipeline stage: Fragment Operations, Fragment Operations
material properties: Defining Material Properties; Define Material Properties for the Objects in the Scene
ambient: Diffuse and Ambient Reflection, Material Colors
changing a single parameter with glColorMaterial(): Changing Material Properties
changing material properties: Changing Material Properties
diffuse: Diffuse and Ambient Reflection, Material Colors
display lists cache values: Display-List Design Philosophy
emission: Emission, Material Colors, Material Emission
enabling color material properties mode: Changing Material Properties
performance when changing: OpenGL Performance Tips
rendering pipeline stage: Per-Vertex Operations, Per-Vertex Operations
RGBA values: RGB Values for Lights and Materials
sample program which changes material properties: Changing Material Properties
sample program which uses glColorMaterial(): Changing Material Properties
shininess: Specular Reflection
specular: Specular Reflection, Material Colors
two-sided lighting: Two-sided Lighting
matrix:
column-major ordering: General-Purpose Transformation Commands
matrix:also see matrix stack: Odds and Ends
choosing which matrix is current: General-Purpose Transformation Commands
current: The Viewing Transformation
danger of extensive changes: OpenGL Correctness Tips
display lists cache matrix operations: Display-List Design Philosophy
identity: OpenGL Performance Tips, General-Purpose Transformation Commands , The Viewing Transformation, A Modeling Transformation Code Example
loading: General-Purpose Transformation Commands
modelview: General-Purpose Transformation Commands , Overview: The Camera Analogy
multiplying matrices: General-Purpose Transformation Commands
NURBS, specifying for sampling: Control NURBS Rendering Properties
orthographic parallel projection: Orthographic Projection
perspective projection: Perspective Projection
projection: The Projection Transformation, General-Purpose Transformation Commands
rotation: Rotation
row-major ordering: General-Purpose Transformation Commands
scaling: Scaling
texture: The Texture Matrix Stack
transformation pipeline: Overview: The Camera Analogy
transformations of homogeneous coordinates: Transforming Vertices
translation: Translation
matrix stack: Manipulating the Matrix Stacks
choosing which matrix stack is current: Manipulating the Matrix Stacks
current matrix stack: Odds and Ends
modelview: The Modelview Matrix Stack
popping: Manipulating the Matrix Stacks
projection: The Projection Matrix Stack
pushing: Manipulating the Matrix Stacks
querying stack depth: The Modelview Matrix Stack
texture: The Texture Matrix Stack
Megahed, Abe: Finding Interference Regions
Microsoft:
Microsoft Win32, See Win32: WGL: OpenGL Extension for Microsoft Windows NT and Windows 95
Microsoft Windows: OpenGL-Related Libraries
Microsoft Windows 95: WGL: OpenGL Extension for Microsoft Windows NT and Windows 95
Microsoft Windows NT: How to Obtain the Sample Code
Microsoft Windows to OpenGL interface, See WGL: OpenGL-Related Libraries
mipmapping:
texture objects for mipmaps: Creating and Using Texture Objects
mipmapping: Multiple Levels of Detail
minification filters: Filtering
mirroring objects, See scaling: Scale
modeling transformations: Viewing and Modeling Transformations
modeling transformations: Modeling Transformations ; The Modeling Transformation
camera analogy: Overview: The Camera Analogy
connection to viewing transformations: The Modeling Transformation
example: A Modeling Transformation Code Example
rotation: Rotate
rotation matrix: Rotation
sample program: A Modeling Transformation Code Example
scaling: Scale
scaling matrix: Scaling
translation: Translate
translation matrix: Translation
models:
rendering wireframe and solid: Drawing Three-Dimensional Objects, Initializing and Drawing Three-Dimensional Objects
modelview matrix: General-Purpose Transformation Commands ; Overview: The Camera Analogy
arbitrary clipping planes, effect on: Additional Clipping Planes
stack: The Modelview Matrix Stack
motion blur: Motion Blur
stippling, with: An Easy Fade Effect
motion, See animation: Animation
movie clips: Alternative Uses for glDrawPixels() and glCopyPixels()
multiple layers:
displaying with overlap: Displaying Layers
name stack: The Basic Steps
creating: Creating the Name Stack
initializing: Creating the Name Stack
loading: Creating the Name Stack
multiple names: Picking with Multiple Names and a Hierarchical Model
popping: Creating the Name Stack
pushing: Creating the Name Stack
querying maximum depth: Creating the Name Stack
networked operation: Forcing Completion of Drawing
attribute groups, saving and restoring: Attribute Groups
display lists: What's Stored in a Display List
versions: Which Version Am I Using?
Non-Uniform Rational B-Splines, see NURBS: OpenGL-Related Libraries
nonplanar polygons: Polygons
normal vectors:
normalized: Normal Vectors
normal vectors: Define Normal Vectors for Each Vertex of Every Object; Normal Vectors
calculating: Calculating Normal Vectors
calculating for analytic surfaces: Finding Normals for Analytic Surfaces
calculating for polygonal data: Finding Normals from Polygonal Data
calculating length: Normal Vectors
cross product, calculating normalized: Calculating Normal Vectors for a Surface
enabling automatic unit length division: Normal Vectors
inverse matrix generated: Odds and Ends
matrix transformations: Overview: The Camera Analogy
NURBS, generating for: Create a NURBS Curve or Surface
quadrics, generated for: Control Quadrics Attributes
rendering pipeline stage: Per-Vertex Operations, Per-Vertex Operations
specifying: Normal Vectors
tessellation, specifying for: Tessellation Callback Routines
transformations: Transforming Normals
unit length optimizes performance: OpenGL Performance Tips
vertex arrays, specifying values with: Step 2: Specifying Data for the Arrays
normal, See normal vectors: Normal Vectors
normalized device coordinates: Overview: The Camera Analogy
NURB Curves and Surfaces (book title): Prerequisites
NURBS: The GLU NURBS Interface
creating a NURBS curve or surface: Create a NURBS Curve or Surface
creating a NURBS object: Manage a NURBS Object
culling: Control NURBS Rendering Properties
deleting a NURBS object: Manage a NURBS Object
display list use: An Example of Using a Display List
error handling: Handle NURBS Errors
method of display (lines or filled polygons): Control NURBS Rendering Properties
normal vectors, generating: Create a NURBS Curve or Surface
properties, controlling NURBS: Control NURBS Rendering Properties
querying property value: Control NURBS Rendering Properties
references: Prerequisites
sample program which draws a lit NURBS surface: A Simple NURBS Example
sample program with a trimmed surface: Trim a NURBS Surface
sampling precision: Control NURBS Rendering Properties
source for matrices: Control NURBS Rendering Properties
steps to use: A Simple NURBS Example
texture coordinate generation: Create a NURBS Curve or Surface
trimming: Trim a NURBS Surface
NURBS Book, The: Prerequisites
NURBS for Curve and Surface Design: Prerequisites
object coordinates: Overview: The Camera Analogy
texture coordinate generation: Automatic Texture-Coordinate Generation
objects, See models: Drawing Three-Dimensional Objects
opacity: Blending
Open Inventor: OpenGL-Related Libraries; What Is OpenGL?
OpenGL Extension to the X Window System, see GLX: OpenGL-Related Libraries
OpenGL Programming for the X Window System: OpenGL-Related Libraries; GLUT, the OpenGL Utility Toolkit;
Basics of GLUT: The OpenGL Utility Toolkit; How to Obtain the Sample Code; GLX: OpenGL Extension for the X Window System
OpenGL Reference Manual: GLX: OpenGL Extension for the X Window System
OpenGL Reference Manual: Order of Operations; What You Should Know Before Reading This Guide; The Query Commands
OpenGL Utility Library, see GLU: OpenGL-Related Libraries
OpenGL Utility Toolkit, see GLUT: OpenGL-Related Libraries
orthographic parallel projection: The Projection Transformation; Orthographic Projection
jittering: Scene Antialiasing
matrix: Orthographic Projection
specifying with integer coordinates: OpenGL Correctness Tips
outlined polygons: Marking Polygon Boundary Edges; Polygons as Points, Outlines, or Solids
polygon offset solution: Polygon Offset
overlapping objects: Finding Interference Regions
painting: Blending; Alternative Uses for glDrawPixels() and glCopyPixels(); Sample Uses of Blending
partial disks: Quadrics: Rendering Spheres, Cylinders, and Disks
pass-through markers: Using Markers in Feedback Mode
performance tips:
light sources, effect of additional: Create, Position, and Enable One or More Light Sources
performance tips:
clearing the window: Clearing the Window
display lists: An Example of Using a Display List
flat shading: OpenGL Performance Tips
flushing the pipeline: Forcing Completion of Drawing
fog: Fog
GLX tips: GLX Tips
hints: Antialiasing
light source attenuation, effect of: Position and Attenuation
list of general tips: OpenGL Performance Tips
material properties, changing: OpenGL Performance Tips
NURBS and display lists: An Example of Using a Display List
pixel data alignment: Controlling Pixel-Storage Modes
pixel data, drawing: Tips for Improving Pixel Drawing Rates
polygon restrictions: Polygons
polygon subdivision: Some Hints for Building Polygonal Models of Surfaces
pushing and popping attribute groups: OpenGL Performance Tips
rasterization and fragment operations for pixel data: OpenGL Performance Tips
removing hidden surfaces: A Hidden-Surface Removal Survival Kit
specifying geometric primitives: OpenGL Performance Tips
tessellation and display lists: An Example of Using a Display List
tessellation, use of: Tessellator Performance Tips
texture images, internal format of: Specifying the Texture
texture objects: OpenGL Performance Tips, Texture Objects
texture subimages: OpenGL Performance Tips
two-sided lighting: Two-sided Lighting
unit-length normal vectors: OpenGL Performance Tips
vector and scalar forms of commands: OpenGL Performance Tips
vertex arrays: OpenGL Performance Tips
perspective projection: Perspective Projection
correction hint: A Sample Program, A Sample Program, Antialiasing
depth coordinates, effect on: The Transformed Depth Coordinate
jittering: Scene Antialiasing
matrix: Perspective Projection
perspective division: Overview: The Camera Analogy
PGL:
pglIsIndirect(): Managing an OpenGL Rendering Context
PGL: PGL: OpenGL Extension for IBM OS/2 Warp; OpenGL-Related Libraries
pglChooseConfig(): Initialization, Initialization
pglCopyContext(): Managing an OpenGL Rendering Context, Controlling Rendering
pglCreateContext(): Controlling Rendering, Managing an OpenGL Rendering Context
pglDestroyContext(): Managing an OpenGL Rendering Context, Controlling Rendering
pglGetCurrentContext(): Controlling Rendering, Managing an OpenGL Rendering Context
pglGetCurrentWindow(): Managing an OpenGL Rendering Context, Controlling Rendering
pglGrabFrontBitmap(): Controlling Rendering, Access the Bitmap of the Front Buffer
pglIsIndirect(): Controlling Rendering
pglMakeCurrent(): Managing an OpenGL Rendering Context, Controlling Rendering
pglQueryCapability(): Initialization, Initialization
pglQueryConfigs(): Initialization, Initialization
pglQueryVersion(): Initialization, Initialization
pglReleaseFrontBitmap(): Controlling Rendering, Access the Bitmap of the Front Buffer
pglSelectColorIndexPalette(): Controlling Rendering, When you are running in 8-bit (256 color) mode, you have to worry about color palette management. For windows with a color + index Visual Configuration, call pglSelectColorIndexPalette() to tell OpenGL what color-index palette you want to use with your context. A color palette must be selected before the context is initially bound to a window. In RGBA mode, OpenGL sets up a palette automatically.
pglSwapBuffers(): Controlling Rendering, Swapping Buffers
pglUseFont(): Using an OS/2 Logical Font, Controlling Rendering
pglWaitGL(): Controlling Rendering, Synchronizing Execution
pglWaitPM(): Synchronizing Execution, Controlling Rendering
picking: Picking
back buffer for, using the: Object Selection Using the Back Buffer
depth coordinates: Picking and Depth Values
hierarchical models: Picking with Multiple Names and a Hierarchical Model
projection matrix, special: Picking
sample program: Picking
sample program with depth coordinates: Picking and Depth Values
strategies: Hints for Writing a Program That Uses Selection
sweep selection: Hints for Writing a Program That Uses Selection
Piegl, Les: Prerequisites
pipeline:
geometric processing: Geometric Operations
imaging: Reading, Writing, and Copying Pixel Data, Imaging Pipeline
rendering: OpenGL Rendering Pipeline
vertex transformation: Overview: The Camera Analogy
pixel:
coverage: Antialiasing
pixel data: Drawing Pixels, Bitmaps, Fonts, and Images; Images
aaa: Pixel Operations
byte alignment: Controlling Pixel-Storage Modes
byte ordering: Controlling Pixel-Storage Modes
copying within the framebuffer: Imaging Pipeline, Copying Pixel Data within the Frame Buffer, Pixel Operations, Pixel Operations, Reading, Writing, and Copying Pixel Data
depth buffer pixel data: Pixel-Transfer Operations, Copying Pixel Data within the Frame Buffer
drawing or reading a subrectangle of: Controlling Pixel-Storage Modes
drawing process in detail: The Pixel Rectangle Drawing Process
endianness: Controlling Pixel-Storage Modes
feedback mode: The Feedback Array
formats for reading or drawing: Reading Pixel Data from Frame Buffer to Processor Memory
formats for storing in memory: Reading Pixel Data from Frame Buffer to Processor Memory, Pixel Packing and Unpacking
mapping: Pixel Operations, Pixel Operations, Pixel Mapping
packing into processor memory: Pixel Operations, Pixel Packing and Unpacking, Pixel Operations
performance tips: Tips for Improving Pixel Drawing Rates
pipeline operations: Imaging Pipeline, Pixel Operations, Reading, Writing, and Copying Pixel Data, Pixel Operations
pixel zoom: Magnifying, Reducing, or Flipping an Image
querying pixel mapping information: Pixel Mapping
reading from the framebuffer: Reading, Writing, and Copying Pixel Data, Reading Pixel Data from Frame Buffer to Processor Memory
reading process in detail: The Pixel Rectangle Reading Process
sample code which draws an image: Writing Pixel Data from Processor Memory to Frame Buffer
sample program which draws, copies, and zooms pixel data: Magnifying, Reducing, or Flipping an Image
stencil buffer pixel data: Pixel-Transfer Operations, Reading Pixel Data from Frame Buffer to Processor Memory
storage modes: Controlling Pixel-Storage Modes
transfer modes: Pixel Operations, Pixel Operations, Texture Functions, Pixel-Transfer Operations
unpacking from processor memory: Pixel Operations, Pixel Packing and Unpacking, Pixel Operations
writing to the framebuffer: Reading, Writing, and Copying Pixel Data, Writing Pixel Data from Processor Memory to Frame Buffer
points:
drawing: OpenGL Geometric Drawing Primitives
point light source, See positional light source: Position and Attenuation
points: Points
antialiasing: Antialiasing Points or Lines, Drawing Round Points
feedback mode: The Feedback Array
querying point size: Point Details
round: Antialiasing Points or Lines, Drawing Round Points
size: Point Details
specifying: OpenGL Geometric Drawing Primitives, OpenGL Geometric Drawing Primitives
polygons:
culling the faces: Reversing and Culling Polygon Faces
polygon mode: Polygons as Points, Outlines, or Solids
reversing the faces: Reversing and Culling Polygon Faces
stippling: Stippling Polygons
polygon offset: Polygon Offset
depth slope of a polygon: Polygon Offset
enabling: Polygon Offset
hidden-line removal: Hidden-Line Removal with Polygon Offset
polygonal approximations to surfaces: Some Hints for Building Polygonal Models of Surfaces
polygons: Polygons
boundary edges: Marking Polygon Boundary Edges
concave, drawing filled: Drawing Filled, Concave Polygons Using the Stencil Buffer, Polygon Tessellation
convex: Polygons
drawing: OpenGL Geometric Drawing Primitives
drawing as points, lines, or filled: Polygons as Points, Outlines, or Solids
feedback mode: The Feedback Array
front and back faces: Reversing and Culling Polygon Faces
holes in: Polygons
non-convex: Polygons, Marking Polygon Boundary Edges
nonplanar: Polygons
polygon mode: Primitive Assembly, OpenGL Performance Tips, Primitive Assembly
sample program with stippled polygons: Stippling Polygons
self-intersecting: Tessellation Callback Routines
simple: Polygons
specifying: OpenGL Geometric Drawing Primitives, OpenGL Geometric Drawing Primitives
tessellation, specifying for: Polygon Definition
Voronoi: Dirichlet Domains
positional light source: Position and Attenuation
primitives:
geometric: Describing Points, Lines, and Polygons
raster: Drawing Pixels, Bitmaps, Fonts, and Images
priority of texture objects: Texture Residence Strategies
Procedural Elements for Computer Graphics: Quadrics: Rendering Spheres, Cylinders, and Disks
programs:
aaindex.c: Antialiasing in Color-Index Mode
aapoly.c: Antialiasing Polygons
aargb.c: Antialiasing in RGBA Mode
accanti.c: Scene Antialiasing
accpersp.c: Scene Antialiasing
alpha.c: A Blending Example
alpha3D.c: Three-Dimensional Blending with the Depth Buffer
bezcurve.c: One-Dimensional Example: A Simple Bézier Curve
bezmesh.c: Defining Evenly Spaced Coordinate Values in Two Dimensions
bezsurf.c: Two-Dimensional Example: A Bézier Surface
checker.c: A Sample Program
clip.c: A Clipping Plane Code Example
colormat.c: Changing Material Properties
cube.c: A Simple Example: Drawing a Cube
dof.c: Depth of Field
double.c: Motion = Redraw + Swap
drawf.c: Bitmaps and Fonts
feedback.c: A Feedback Example
fog.c: Using Fog
fogindex.c: Fog in Color-Index Mode
font.c: Defining and Using a Complete Font
ftp site: How to Obtain the Sample Code
hello.c: Running the Program
image.c: Magnifying, Reducing, or Flipping an Image
light.c: A Simple Example: Rendering a Lit Sphere
lines.c: Stippled Lines
list.c: Creating and Executing a Display List
material.c: Changing Material Properties
mipmap.c: Multiple Levels of Detail
model.c: A Modeling Transformation Code Example
movelight.c: Independently Moving the Light
pickdepth.c: Picking and Depth Values
picksquare.c: Picking
planet.c: Building a Solar System
polys.c: Stippling Polygons
quadric.c: Quadrics Primitives
robot.c: Building an Articulated Robot Arm
select.c: A Selection Example
smooth.c: Specifying a Shading Model
stencil.c: Stencil Examples
stroke.c: Executing Multiple Display Lists
surface.c: A Simple NURBS Example
tess.c: Tessellation Callback Routines, Tessellation Callback Routines, Polygon Definition
texbind.c: Creating and Using Texture Objects
texgen.c: Creating Contours
texsub.c: Replacing All or Part of a Texture Image
texturesurf.c: Using Evaluators for Textures
torus.c, using a display list: An Example of Using a Display List
trim.c: Trim a NURBS Surface
unproject.c: Reversing or Mimicking Transformations
varray.c: Step 2: Specifying Data for the Arrays
projecting images: Texture-Mapping Applications
projection matrix: The Projection Transformation; General-Purpose Transformation Commands
matrix stack: The Projection Matrix Stack
orthographic parallel projection matrix: Orthographic Projection
perspective projection matrix: Perspective Projection
shadows created with: Shadows
projection transformations: The Projection Transformation; Projection Transformations
camera lens analogy: Overview: The Camera Analogy
collapsing geometry to a single plane: OpenGL Correctness Tips
jittering: Scene Antialiasing, Scene Antialiasing
orthographic parallel: OpenGL Correctness Tips, The Projection Transformation, Orthographic Projection
perspective: Perspective Projection
picking: Picking
texturing effects: The q Coordinate
two-dimensional: Orthographic Projection
proxy textures: Texture Proxy
q texture coordinates: The q Coordinate
avoiding negative values: OpenGL Correctness Tips
quadratic attenuation: Position and Attenuation
quadrics: Quadrics: Rendering Spheres, Cylinders, and Disks
creating an object: Manage Quadrics Objects
destroying an object: Manage Quadrics Objects
drawing as points, lines, and filled polygons: Control Quadrics Attributes
error handling: Manage Quadrics Objects
normal vectors, generating: Control Quadrics Attributes
orientation: Control Quadrics Attributes
quadratic equation: Quadrics: Rendering Spheres, Cylinders, and Disks
sample program: Quadrics Primitives
steps to use: Quadrics: Rendering Spheres, Cylinders, and Disks
texture coordinates, generating: Control Quadrics Attributes
quadrilateral:
specifying: OpenGL Geometric Drawing Primitives, OpenGL Geometric Drawing Primitives
strip, specifying: OpenGL Geometric Drawing Primitives, OpenGL Geometric Drawing Primitives
raster position: The Current Raster Position
after drawing a bitmap: Drawing the Bitmap
current: Odds and Ends, The Current Raster Position
current raster color: Choosing a Color for the Bitmap
current, obtaining the: The Current Raster Position
transformation of: The Current Raster Position
rasterization: Computer Color; The Framebuffer
exact, two-dimensional: OpenGL Correctness Tips
rendering pipeline stage: Rasterization
reading pixel data, See pixel data: Drawing Pixels, Bitmaps, Fonts, and Images
Real Projective Plane, The: Homogeneous Coordinates and Transformation Matrices
rectangles:
specifying: Rectangles
reducing images: Magnifying, Reducing, or Flipping an Image
reflecting objects, See scaling: Scale
reflection, See material properties: Material Colors
reflective objects, See environment mapping: Environment Mapping
refresh, screen: Animation
removing hidden surfaces, See hidden-surface removal: A Hidden-Surface Removal Survival Kit
repeatability: OpenGL Invariance
resident textures: Texture Proxy; A Working Set of Resident Textures
management strategies: Texture Residence Strategies
querying residence status: A Working Set of Resident Textures
RGBA mode: RGBA Display Mode
changing between color-index mode and: Changing between Display Modes
choosing between color-index mode and: Choosing between RGBA and Color-Index Mode
coverage calculations for antialiasing: Antialiasing
data type conversion: Specifying a Color in RGBA Mode
light source colors: RGB Values for Lights and Materials
lighting calculations in: The Mathematics of Lighting
material property values: RGB Values for Lights and Materials
vertex arrays, specifying values with: Step 2: Specifying Data for the Arrays
robot arm example: Building an Articulated Robot Arm
Rogers, David: Quadrics: Rendering Spheres, Cylinders, and Disks
Rossignac, Jarek: Finding Interference Regions
rotating images: Texture-Mapping Applications
rotation: Rotate
matrix: Rotation
sample programs, See programs: Running the Program
scaling: Scale
matrix: Scaling
scaling images: Texture-Mapping Applications
Schneider, Bengt-Olaf: Finding Interference Regions
Scientific American: Life in the Stencil Buffer
scissor test: Scissor Test
and clearing: Clearing Buffers
rendering pipeline stage: Fragment Operations, Fragment Operations
Segal, Mark: The q Coordinate
selection: Selection
back buffer for, using the: Object Selection Using the Back Buffer
hit records: The Hit Record
programming tips: Hints for Writing a Program That Uses Selection
querying current rendering mode: The Basic Steps
rendering pipeline stage: Primitive Assembly
sample program: A Selection Example
steps to perform: The Basic Steps
sweep selection: Hints for Writing a Program That Uses Selection
shading:
flat: Specifying a Shading Model
smooth: Specifying a Shading Model
shading:
performance tips: OpenGL Performance Tips
sample program with smooth shading: Specifying a Shading Model
specifying shading model: Specifying a Shading Model
shadows: The Mathematics of Lighting; Soft Shadows; Shadows
shininess: Specular Reflection
aaa: Environment Mapping
silhouette edges: Some Hints for Building Polygonal Models of Surfaces
smoke, See fog: Fog
smooth shading: Specifying a Shading Model
solar system example: Building a Solar System
source factor, See blending: The Source and Destination Factors
specular:
contribution to lighting equation: Specular Term
light: Ambient, Diffuse, and Specular Light
material properties: Material Colors, Specular Reflection
spheres: Initializing and Drawing Three-Dimensional Objects; Quadrics: Rendering Spheres, Cylinders, and Disks
split-screen:
multiple viewports: Defining the Viewport
spotlights, See light sources: Spotlights
state machine: OpenGL as a State Machine
state variables: Basic State Management
attribute groups: Attribute Groups
display list execution, effect of: Managing State Variables with Display Lists
enable and disable states: Basic State Management
list of: OpenGL State Variables
performance of storing and restoring: OpenGL Performance Tips
querying: Basic State Management
stencil buffer:
clearing: Clearing the Window
stencil buffer: Stencil Buffer; Buffers and Their Uses
clearing: Clearing Buffers
concave polygons, for drawing: Drawing Filled, Concave Polygons Using the Stencil Buffer
decals, for: Making Decals
Dirichlet domains, for: Dirichlet Domains
Game of Life, for the: Life in the Stencil Buffer
hidden-line removal: Hidden-Line Removal with the Stencil Buffer
masking: Masking Buffers
pixel data: Pixel-Transfer Operations, Reading Pixel Data from Frame Buffer to Processor Memory
stencil test: Stencil Test
examples of using: Stencil Examples
interference regions found using clipping planes: Finding Interference Regions
querying stencil parameters: Stencil Queries
rendering pipeline stage: Fragment Operations, Fragment Operations
sample program: Stencil Examples
stereo: Selecting Color Buffers for Writing and Reading; Color Buffers
querying its presence: Color Buffers
stippling:
lines: Stippled Lines
stippling:
display lists cache stipple patterns: Display-List Design Philosophy
enabling line stippling: Stippled Lines
enabling polygon stippling: Stippling Polygons
fade effect, use for: An Easy Fade Effect
line pattern reset: Stippled Lines
line pattern reset: A Feedback Example, The Feedback Array
polygons: Stippling Polygons
sample program with line stipple: Stippled Lines
sample program with polygon stippling: Stippling Polygons
stencil test, use of: Stencil Examples
translucency, use to simulate: Cheesy Translucency
stitching: Polygon Offset
stretching objects, See scaling: Scale
stride:
vertex arrays: Interleaved Arrays, Stride
subdivision: Some Hints for Building Polygonal Models of Surfaces
generalized: Generalized Subdivision
icosahedron example: Improving the Model
recursive: Improving the Model
subimages: One-Dimensional Textures; Replacing All or Part of a Texture Image
superimposing images: Making Decals
surface normals, See normal vectors: Normal Vectors
surfaces, See evaluators or NURBS: Evaluators and NURBS
swapping buffers, See double-buffering: Animation
syntax, See command syntax: OpenGL Command Syntax
Terminator 2: Environment Mapping
tessellation: Polygon Tessellation; Polygons
backward compatibility with obsolete routines: Backward Compatibility
begin and end callback routines: Tessellation Callback Routines
callback routines: Tessellation Callback Routines
combine callback routine: Tessellation Callback Routines, Tessellation Callback Routines
computational solid geometry, winding rules used for: CSG Uses for Winding Rules
contours, specifying: Polygon Definition
converting code to use the GLU 1.2 tessellator: Backward Compatibility
creating an object: Create a Tessellation Object
decomposition into geometric primitives: Tessellation Callback Routines
deleting objects: Deleting a Tessellator Object
display list use: An Example of Using a Display List
edge flag generation: Tessellation Callback Routines
error handling: Tessellation Callback Routines
evaluators used to perform: OpenGL Performance Tips
interior and exterior, determining: Winding Numbers and Winding Rules
intersecting contours combined: Tessellation Callback Routines, Tessellation Callback Routines
performance tips: Tessellator Performance Tips
polygons, specifying: Polygon Definition
properties: Tessellation Properties
reuse of objects: Tessellator Performance Tips, Create a Tessellation Object
reversing winding direction: Other Tessellation Property Routines
sample code: Polygon Definition, Tessellation Callback Routines, Tessellation Callback Routines
user-specified data: User-Specified Data
vertices, specifying: Polygon Definition, Tessellation Callback Routines
winding rules: Winding Numbers and Winding Rules
texels: Fragment Operations; Texture Mapping
text, see characters: Texture-Mapping Applications
texture coordinates: A Sample Program; Assigning Texture Coordinates
assigning manually: Assigning Texture Coordinates
avoiding negative q values: OpenGL Correctness Tips
clamping: Repeating and Clamping Textures
computing manually: Computing Appropriate Texture Coordinates
enabling automatic generation of: Creating Contours
environment mapping, automatic generation for: Environment Mapping
evaluators, generated by: Using Evaluators for Textures
generating automatically: Automatic Texture-Coordinate Generation
NURBS, generating for: Create a NURBS Curve or Surface
q coordinate: The q Coordinate
quadrics, generated for: Control Quadrics Attributes
reference planes, specifying: Automatic Texture-Coordinate Generation
rendering pipeline stage: Per-Vertex Operations, Per-Vertex Operations
repeating: Repeating and Clamping Textures
sample program with texture coordinate generation: Creating Contours
tessellation, specifying for: Tessellation Callback Routines
vertex arrays, specifying values with: Step 2: Specifying Data for the Arrays
wrapping modes: Repeating and Clamping Textures
texture functions: Texture Functions
blend: Texture Functions
blending color: Texture Functions
decal: Texture Functions, A Sample Program
fragment operations: Texture Functions
modulate: Texture Functions
pixel-transfer modes effect: Texture Functions
replace: Texture Functions
texture internal format, interaction with: Texture Functions
texture images:
alpha data: Texture Functions
borders: Repeating and Clamping Textures, Using a Texture's Borders
components: Specifying the Texture
data types: Specifying the Texture
distorting: Computing Appropriate Texture Coordinates
framebuffer as a source of: One-Dimensional Textures, Specifying the Texture, Replacing All or Part of a Texture Image
imaging pipeline operations: Imaging Pipeline
intensity data: Texture Functions
internal format: Specifying the Texture
luminance data: Texture Functions
mipmaps: Multiple Levels of Detail
one-dimensional: One-Dimensional Textures
performance affected by internal format: Specifying the Texture
performance of texture subimages: OpenGL Performance Tips
power of 2 size restriction: Specifying the Texture
proxy textures: Texture Proxy
querying maximum size: Texture Proxy
residence status: A Working Set of Resident Textures
resident textures: A Working Set of Resident Textures, Texture Proxy
resident textures, management strategies of: Texture Residence Strategies
sample program with mipmaps: Multiple Levels of Detail
sample program with subimages: Replacing All or Part of a Texture Image
specifying: Specifying the Texture
subimages: Replacing All or Part of a Texture Image, One-Dimensional Textures
working set of textures: Texture Proxy, Texture Objects, A Working Set of Resident Textures
texture mapping, see texturing: Texture Mapping
texture matrix: The Texture Matrix Stack
rendering pipeline stage: Per-Vertex Operations
texture objects: A Sample Program; Texture Objects
binding: Creating and Using Texture Objects
creating: Creating and Using Texture Objects
data which can be stored in: Creating and Using Texture Objects
deleting: Cleaning Up Texture Objects
fragmentation of texture memory: Texture Residence Strategies
least-recently used (LRU) strategy: Texture Residence Strategies
mipmaps: Creating and Using Texture Objects
naming: Naming A Texture Object
performance tips: OpenGL Performance Tips, Texture Objects
priority: Texture Residence Strategies
rendering pipeline: Texture Memory, Texture Assembly
sample program: A Sample Program
sample program with multiple texture objects: Creating and Using Texture Objects
sharing among rendering contexts: Managing an OpenGL Rendering Context, Managing an OpenGL Rendering Context
steps to perform: Texture Objects
using: Creating and Using Texture Objects
texturing:also see texture coordinates, texture functions, texture images, texture matrix, and texture objects: Steps in Texture Mapping
antialiasing characters: Texture-Mapping Applications
antialiasing lines: Texture-Mapping Applications
blending: Sample Uses of Blending
border colors, treatment of: Repeating and Clamping Textures
color-index mode limitations: Specifying the Texture, Steps in Texture Mapping
creating contours: Creating Contours
decals with alpha testing: Alpha Test
display lists cache texture data: Display-List Design Philosophy
enabling: Enable Texture Mapping, A Sample Program
environment mapping: Environment Mapping
filtering: Filtering
image transformations: Texture-Mapping Applications
mipmapping: Multiple Levels of Detail, Filtering
perspective correction hint: A Sample Program, A Sample Program
rendering pipeline stage: Texture Assembly, Texture Memory
sample program: A Sample Program
sample program with evaluated, Bézier surface: Using Evaluators for Textures
sample program with mipmapping: Multiple Levels of Detail
sample program with texture coordinate generation: Creating Contours
sample uses for: Texture-Mapping Applications
simulating shadows or spotlights: The q Coordinate
steps to perform: Steps in Texture Mapping
what's new in release 1.1: Texture Mapping
3D models, rendering: Initializing and Drawing Three-Dimensional Objects; Drawing Three-Dimensional Objects; What You Should Know Before Reading This Guide
Tiller, Wayne: Prerequisites
tips, programming: Programming Tips
aaa: Programming Tips
error handling: OpenGL Correctness Tips
selection and picking: Hints for Writing a Program That Uses Selection
transformations: Troubleshooting Transformations
transformations:
display lists cache transformations: Display-List Design Philosophy
modeling: Viewing and Modeling Transformations
projection: The Projection Transformation
viewing: Viewing and Modeling Transformations
viewport: The Viewport Transformation
transformations:also see modeling transformations, projection transformations, viewing transformations, and viewport transformations: Overview: The Camera Analogy
combining multiple: Examples of Composing Several Transformations
general-purpose commands: General-Purpose Transformation Commands
matrices: Transformation Matrices
mimicking the geometric processing pipeline: Reversing or Mimicking Transformations
modeling: Modeling Transformations
ordering correctly: Thinking about Transformations
overview: Viewing
performance tips: OpenGL Performance Tips
projection: Projection Transformations
reversing the geometric processing pipeline: Reversing or Mimicking Transformations
sample program: A Simple Example: Drawing a Cube
sample program combining modeling transformations: Building an Articulated Robot Arm, Building a Solar System
sample program for modeling transformations: A Modeling Transformation Code Example
sample program showing reversal of transformation pipeline: Reversing or Mimicking Transformations
troubleshooting: Troubleshooting Transformations
units: Perspective Projection
viewing: Viewing Transformations
viewport: Viewport Transformation
translation: Translate
matrix: Translation
translucent objects: Blending; Cheesy Translucency
stencil test, creating with the: Stencil Examples
transparent objects: Blending
creating with the alpha test: Alpha Test
transposing images: Alternative Uses for glDrawPixels() and glCopyPixels(); Alternative Uses for glDrawPixels() and glCopyPixels()
triangle:
fan, specifying: OpenGL Geometric Drawing Primitives, OpenGL Geometric Drawing Primitives
specifying: OpenGL Geometric Drawing Primitives, OpenGL Geometric Drawing Primitives
strip, specifying: OpenGL Geometric Drawing Primitives, OpenGL Geometric Drawing Primitives
tessellated polygons decomposed into: Tessellation Callback Routines
trimming:
curves and curved surfaces: Trim a NURBS Surface
sample program: Trim a NURBS Surface
two-sided lighting: Two-sided Lighting
up-vector: The Viewing Transformation
Utility Library, OpenGL, see GLU: OpenGL-Related Libraries
Utility Toolkit, OpenGL, see GLUT: OpenGL-Related Libraries
van Dam, Andries: What You Should Know Before Reading This Guide; RGBA versus Color-Index Mode; Homogeneous Coordinates and Transformation Matrices
van Widenfelt, Rolf: The q Coordinate
vendor-specific extensions: Extensions to the Standard
versions: Which Version Am I Using?
GLU: Utility Library Version
vertex: Describing Points, Lines, and Polygons
aaa: Vertex Arrays
evaluators, generating with: Evaluators
feedback mode: The Feedback Array
per-vertex operations pipeline stage: Per-Vertex Operations, Per-Vertex Operations
specifying: Specifying Vertices
tessellation, specifying for: Polygon Definition, Tessellation Callback Routines
transformation pipeline: Overview: The Camera Analogy
vertex arrays: Vertex Arrays
dereference a list of array elements: Dereference a List of Array Elements
dereference a sequence of array elements: Dereference a Sequence of Array Elements
dereference a single element: Dereference a Single Array Element
disabling: Step 1: Enabling Arrays
display list use: What's Stored in a Display List
enabling: Step 1: Enabling Arrays
interleaved arrays: Interleaved Arrays
interleaved arrays, specifying: Interleaved Arrays
performance tips: OpenGL Performance Tips
querying: OpenGL State Variables
reuse of vertices: Dereference a List of Array Elements
sample program: Step 2: Specifying Data for the Arrays
specifying data: Step 2: Specifying Data for the Arrays
steps to use: Vertex Arrays
stride between data: Interleaved Arrays, Stride
video:
fake: Alternative Uses for glDrawPixels() and glCopyPixels()
flipping an image with glPixelZoom(): Magnifying, Reducing, or Flipping an Image
textured images: Replacing All or Part of a Texture Image
viewing:
camera analogy: Overview: The Camera Analogy
viewing transformations: The Viewing Transformation; Viewing and Modeling Transformations; Viewing Transformations; The Viewing Transformation
connection to modeling transformations: The Modeling Transformation
default position: The Viewing Transformation
pilot view: Creating a Custom Utility Routine
polar view: Creating a Custom Utility Routine
tripod analogy: Overview: The Camera Analogy
up-vector: The Viewing Transformation
viewing volume:
clipping: Viewing Volume Clipping
viewing volume: Perspective Projection
clipping: Additional Clipping Planes
jittering: Scene Antialiasing, Scene Antialiasing
viewpoint:
lighting, for: Local or Infinite Viewpoint
viewport transformations: Viewport Transformation; The Viewport Transformation ; Overview: The Camera Analogy
photograph analogy: Overview: The Camera Analogy
rendering pipeline stage: Primitive Assembly, Primitive Assembly
visual simulation:
fog, use of: Fog
Voronoi polygons: Dirichlet Domains
w coordinates: Points; Drawing the Scene; Overview: The Camera Analogy
avoiding negative values: OpenGL Correctness Tips
lighting, use with: Position and Attenuation
perspective division: The Transformed Depth Coordinate, Primitive Assembly
warping images: Texture-Mapping Applications
Watt, Alan: Texture Mapping
web sites:
IBM OS/2 software and documentation: PGL: OpenGL Extension for IBM OS/2 Warp
Microsoft Developer Network: WGL: OpenGL Extension for Microsoft Windows NT and Windows 95
Silicon Graphics' OpenGL : How to Obtain the Sample Code
Template Graphics Software: AGL: OpenGL Extension to the Apple Macintosh
WGL: OpenGL-Related Libraries; WGL: OpenGL Extension for Microsoft Windows NT and Windows 95
wglCopyContext(): Controlling Rendering, Managing an OpenGL Rendering Context
wglCreateContext(): Controlling Rendering, Managing an OpenGL Rendering Context, Initialization
wglCreateLayerContext(): Managing an OpenGL Rendering Context, Controlling Rendering
wglDeleteContext(): Controlling Rendering
wglDescribeLayerPlane(): Initialization, Initialization
wglDestroyContext(): Managing an OpenGL Rendering Context
wglGetCurrentContext(): Managing an OpenGL Rendering Context, Controlling Rendering
wglGetCurrentDC(): Controlling Rendering, Managing an OpenGL Rendering Context
wglGetLayerPaletteEntries(): Controlling Rendering, Finding a Color Palette
wglMakeCurrent(): Managing an OpenGL Rendering Context, Controlling Rendering
wglRealizeLayerPalette(): Finding a Color Palette, Controlling Rendering
wglShareLists(): Controlling Rendering, Managing an OpenGL Rendering Context
wglSwapLayerBuffers(): Swapping Buffers, Controlling Rendering
wglUseFontBitmaps(): Controlling Rendering, Using a Bitmap or Outline Font
wglUseFontOutlines(): Using a Bitmap or Outline Font, Controlling Rendering
Williams, Lance: Multiple Levels of Detail
Win32:
ChoosePixelFormat(): Initialization, Initialization
CreateDIBitmap(): OpenGL Rendering to a Bitmap, Controlling Rendering
CreateDIBSection(): Controlling Rendering, OpenGL Rendering to a Bitmap
DeleteObject(): OpenGL Rendering to a Bitmap, Controlling Rendering
DescribePixelFormat(): Initialization, Initialization
GetVersion(): Initialization, Initialization
GetVersionEx(): Initialization, Initialization
SetPixelFormat(): Initialization, Initialization
SwapBuffers(): Controlling Rendering, Swapping Buffers
winding rules: Winding Numbers and Winding Rules
computational solid geometry, used for: CSG Uses for Winding Rules
reversing winding direction: Other Tessellation Property Routines
window coordinates: Viewport Transformation; Overview: The Camera Analogy
feedback mode: The Feedback Array
polygon offset: Polygon Offset
window management:
glViewport() called, when window resized: Defining the Viewport
using GLUT: Coordinate System Survival Kit, Window Management
working set of textures: A Working Set of Resident Textures; Texture Proxy; Texture Objects
fragmentation of texture memory: Texture Residence Strategies
writemask, See masking (buffers): Masking Buffers
writing pixel data, See pixel data (drawing): Drawing Pixels, Bitmaps, Fonts, and Images
X Window System: GLX: OpenGL Extension for the X Window System; OpenGL-Related Libraries
client-server rendering: What Is OpenGL?
minimum framebuffer configuration: Buffers and Their Uses
X Visual: GLX: OpenGL Extension for the X Window System, Changing between Display Modes
z buffer, See depth buffer: Depth Buffer
z coordinates, See depth coordinates: The Transformed Depth Coordinate
zooming images: Magnifying, Reducing, or Flipping an Image
filtered: Alternative Uses for glDrawPixels() and glCopyPixels()

| #### OpenGL Programming Guide (Addison-Wesley Publishing Company)